Settings.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of the Zivid API
 *
 * Copyright 2015-2025 (C) Zivid AS
 * All rights reserved.
 *
 * Zivid Software License, v1.0
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of Zivid AS nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * 4. This software, with or without modification, must not be used with any
 * other 3D camera than from Zivid AS.
 *
 * 5. Any software provided in binary form under this license must not be
 * reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY ZIVID AS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ZIVID AS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Contact: Zivid Customer Success Team <customersuccess@zivid.com>
 * Info:    http://www.zivid.com
 ******************************************************************************/
 
#pragma once
 
#include <array>
#include <chrono>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <memory>
#include <optional>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Zivid/DataModel/Detail/Detail.h"
#include "Zivid/DataModel/NodeType.h"
#include "Zivid/DataModel/Traits.h"
#include "Zivid/Detail/CoreExport.h"
#include "Zivid/Detail/TypeTraits.h"
#include "Zivid/Point.h"
#include "Zivid/Range.h"
#include "Zivid/Settings2D.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 a 3D capture or 2D+3D capture with a Zivid camera.)description"
        };
 
        static constexpr size_t version{ 27 };
 
#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()) + "]" };
                }
 
                std::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, 3.0 };
                }
 
                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()) + "]" };
                }
 
                std::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{ 200 }, 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()) + "]" };
                }
 
                std::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()) + "]" };
                }
 
                std::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 Color
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
            static constexpr const char *path{ "Color" };
 
            static constexpr const char *name{ "Color" };
 
            static constexpr const char *description{
                R"description(Specify the settings used for the 2D color image when doing a 2D+3D capture. The value type of this node
is a `Zivid::Settings2D` object.
 
This setting was introduced in SDK 2.14, as the recommended way to define the acquisition and processing
settings for the 2D color image when doing 2D+3D captures.
 
When this setting is set, it controls how the 2D color image of the 2D+3D capture is acquired and processed.
This setting can be used to specify custom acquisition and processing settings that apply only to the 2D
color image. These provided settings does not affect the 3D acquisition or processing.
 
When this setting is not set, then the 2D color image is acquired based on `Settings/Acquisitions` and
`Settings/Sampling/Color`, and processed based on `Settings/Processing/Color`. If `Settings/Sampling/Color`
is set to `disabled`, then no 2D color image is acquired. This behavior is to be consistent with SDK 2.13
and earlier.
 
In the next SDK major version, SDK 3.0, only this `Color` setting will control the 2D color image settings.
The `Settings/Sampling/Color` and `Settings/Processing/Color` settings are deprecated as of 2.14, and will
be removed from the API in SDK 3.0. Zivid recommends all users to use `Settings/Color` to define the 2D
color image settings. Tip: If you want to convert an existing settings.yml file to use `Settings/Color`,
you can import the .yml file into Zivid Studio and then re-export it to .yml.
)description"
            };
 
            using ValueType = Zivid::Settings2D;
 
            Color() = default;
 
            explicit Color(Zivid::Settings2D value)
                : m_opt{ std::move(value) }
            {}
 
            const Zivid::Settings2D &value() const;
 
            Zivid::Settings2D &value();
 
            bool hasValue() const;
 
            void reset();
 
            std::string toString() const;
 
            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);
 
            std::optional<Zivid::Settings2D> m_opt;
 
            friend struct DataModel::Detail::Befriend<Color>;
        };
 
 
        // 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, additional diagnostic data is recorded during capture and included when saving
the frame to a .zdf file. This enables Zivid's Customer Success team to provide better assistance and more
thorough troubleshooting.
 
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 or disable 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);
 
                std::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 Engine
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
            static constexpr const char *path{ "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 Sage engine is built for use cases that require all points to be correct/accurate with
particularly high confidence. This can be very suitable for eliminating problems such as
reflection artifacts. This validation comes at the cost of speed, and sometimes reduced number
of valid points due to the removal of low-confidence data. The Sage Engine is only available
for Zivid 2+R.
)description" };
 
            enum class ValueType
            {
                phase,
                stripe,
                omni,
                sage
            };
            static const Engine phase;  
            static const Engine stripe; 
            static const Engine omni;   
            static const Engine sage;   
 
            static std::set<ValueType> validValues()
            {
                return { ValueType::phase, ValueType::stripe, ValueType::omni, ValueType::sage };
            }
 
            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 == ValueType::sage
                           ? value
                           : throw std::invalid_argument{
                                 "Invalid value: Engine{ "
                                 + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                             };
            }
 
            std::optional<ValueType> m_opt;
 
            friend struct DataModel::Detail::Befriend<Engine>;
        };
 
 
        // 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.
 
These settings are deprecated as of SDK 2.14. These settings will be removed in the next SDK major
version (SDK 3.0). The recommended way to do a 2D+3D capture is to set a `Settings2D` object
in the `Settings/Color` node. Tip: If you want to convert an existing settings.yml file to use the
`Settings/Color` node, you can import the .yml file into Zivid Studio and then re-export it to .yml.
)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.
 
This setting is deprecated as of SDK 2.14. This setting will be removed in the next SDK major
version (SDK 3.0). The recommended way to do a 2D+3D capture is to set a `Settings2D` object
in the `Settings/Color` node. Tip: If you want to convert an existing settings.yml file to use
the `Settings/Color` node, you can import the .yml file into Zivid Studio and then re-export it
to .yml.
)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()) + "]" };
                        }
 
                        std::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.
 
This setting is deprecated as of SDK 2.14. This setting will be removed in the next SDK major
version (SDK 3.0). The recommended way to do a 2D+3D capture is to set a `Settings2D` object
in the `Settings/Color` node. Tip: If you want to convert an existing settings.yml file to use
the `Settings/Color` node, you can import the .yml file into Zivid Studio and then re-export it
to .yml.
)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()) + "]" };
                        }
 
                        std::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.
 
This setting is deprecated as of SDK 2.14. This setting will be removed in the next SDK major
version (SDK 3.0). The recommended way to do a 2D+3D capture is to set a `Settings2D` object
in the `Settings/Color` node. Tip: If you want to convert an existing settings.yml file to use
the `Settings/Color` node, you can import the .yml file into Zivid Studio and then re-export it
to .yml.
)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()) + "]" };
                        }
 
                        std::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.
 
This setting is deprecated as of SDK 2.14. This setting will be removed in the next SDK major
version (SDK 3.0). The recommended way to do a 2D+3D capture is to set a `Settings2D` object
in the `Settings/Color` node. Tip: If you want to convert an existing settings.yml file to use
the `Settings/Color` node, you can import the .yml file into Zivid Studio and then re-export it
to .yml.
)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))
                                             + " }"
                                         };
                        }
 
                        std::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.
 
This setting is deprecated as of SDK 2.14. This setting will be removed in the next SDK major
version (SDK 3.0). The recommended way to do a 2D+3D capture is to set a `Settings2D` object
in the `Settings/Color` node. Tip: If you want to convert an existing settings.yml file to use
the `Settings/Color` node, you can import the .yml file into Zivid Studio and then re-export it
to .yml.
)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()) + "]" };
                    }
 
                    std::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(Filter settings.)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(Cluster removal filter.)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(Enable or disable cluster removal.)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);
 
                            std::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()) + "]" };
                            }
 
                            std::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()) + "]" };
                            }
 
                            std::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(Contrast distortion correction filter.)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(Enable or disable contrast distortion correction.)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);
 
                                std::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(Strength of correction. Higher values give 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()) + "]" };
                                }
 
                                std::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(Contrast distortion removal filter.)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(Enable or disable contrast distortion removal.)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);
 
                                std::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(Threshold for removal. 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()) + "]" };
                                }
 
                                std::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>;
                    };
 
                    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>;
 
                    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;
                    }
 
                    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<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Experimental::ContrastDistortion &get() const
                    {
                        return m_contrastDistortion;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_contrastDistortion);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_contrastDistortion);
                    }
 
                    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;
 
                    friend struct DataModel::Detail::Befriend<Experimental>;
                };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Hole
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                    static constexpr const char *path{ "Processing/Filters/Hole" };
 
                    static constexpr const char *name{ "Hole" };
 
                    static constexpr const char *description{
                        R"description(Contains filters that can be used to deal with holes in the point cloud.)description"
                    };
 
 
                    // 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/Hole/Repair" };
 
                        static constexpr const char *name{ "Repair" };
 
                        static constexpr const char *description{
                            R"description(Fills in point cloud holes 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/Hole/Repair/Enabled" };
 
                            static constexpr const char *name{ "Enabled" };
 
                            static constexpr const char *description{
                                R"description(Enable or disable hole 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);
 
                            std::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/Hole/Repair/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()) + "]" };
                            }
 
                            std::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/Hole/Repair/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()) + "]" };
                            }
 
                            std::optional<int32_t> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Strictness>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Hole::Repair::Enabled,
                            Settings::Processing::Filters::Hole::Repair::HoleSize,
                            Settings::Processing::Filters::Hole::Repair::Strictness>;
 
                        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;
                        }
 
                        const HoleSize &holeSize() const
                        {
                            return m_holeSize;
                        }
 
                        HoleSize &holeSize()
                        {
                            return m_holeSize;
                        }
 
                        Repair &set(const HoleSize &value)
                        {
                            m_holeSize = value;
                            return *this;
                        }
 
                        const Strictness &strictness() const
                        {
                            return m_strictness;
                        }
 
                        Strictness &strictness()
                        {
                            return m_strictness;
                        }
 
                        Repair &set(const Strictness &value)
                        {
                            m_strictness = value;
                            return *this;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Hole::Repair::Enabled>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Hole::Repair::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Hole::Repair::HoleSize>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Hole::Repair::HoleSize &get() const
                        {
                            return m_holeSize;
                        }
 
                        template<
                            typename T,
                            typename std::enable_if<
                                std::is_same<T, Settings::Processing::Filters::Hole::Repair::Strictness>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Hole::Repair::Strictness &get() const
                        {
                            return m_strictness;
                        }
 
                        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                        const Settings::Processing::Filters::Hole::Repair::Enabled &get() const
                        {
                            return m_enabled;
                        }
 
                        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
                        const Settings::Processing::Filters::Hole::Repair::HoleSize &get() const
                        {
                            return m_holeSize;
                        }
 
                        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
                        const Settings::Processing::Filters::Hole::Repair::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 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;
                        HoleSize m_holeSize;
                        Strictness m_strictness;
 
                        friend struct DataModel::Detail::Befriend<Repair>;
                    };
 
                    using Descendants = std::tuple<
                        Settings::Processing::Filters::Hole::Repair,
                        Settings::Processing::Filters::Hole::Repair::Enabled,
                        Settings::Processing::Filters::Hole::Repair::HoleSize,
                        Settings::Processing::Filters::Hole::Repair::Strictness>;
 
                    Hole();
 
#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 Hole(Args &&...args)
                    {
                        using namespace Zivid::Detail::TypeTraits;
 
                        static_assert(
                            AllArgsDecayedAreUnique<Args...>::value,
                            "Found duplicate types among the arguments passed to Hole(...). "
                            "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
                    Hole 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 Repair &repair() const
                    {
                        return m_repair;
                    }
 
                    Repair &repair()
                    {
                        return m_repair;
                    }
 
                    Hole &set(const Repair &value)
                    {
                        m_repair = value;
                        return *this;
                    }
 
                    Hole &set(const Repair::Enabled &value)
                    {
                        m_repair.set(value);
                        return *this;
                    }
 
                    Hole &set(const Repair::HoleSize &value)
                    {
                        m_repair.set(value);
                        return *this;
                    }
 
                    Hole &set(const Repair::Strictness &value)
                    {
                        m_repair.set(value);
                        return *this;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Hole::Repair>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Hole::Repair &get() const
                    {
                        return m_repair;
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Hole::Repair::Enabled>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Hole::Repair::Enabled &get() const
                    {
                        return m_repair.get<Settings::Processing::Filters::Hole::Repair::Enabled>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Hole::Repair::HoleSize>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Hole::Repair::HoleSize &get() const
                    {
                        return m_repair.get<Settings::Processing::Filters::Hole::Repair::HoleSize>();
                    }
 
                    template<
                        typename T,
                        typename std::enable_if<
                            std::is_same<T, Settings::Processing::Filters::Hole::Repair::Strictness>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Hole::Repair::Strictness &get() const
                    {
                        return m_repair.get<Settings::Processing::Filters::Hole::Repair::Strictness>();
                    }
 
                    template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                    const Settings::Processing::Filters::Hole::Repair &get() const
                    {
                        return m_repair;
                    }
 
                    template<typename F>
                    void forEach(const F &f) const
                    {
                        f(m_repair);
                    }
 
                    template<typename F>
                    void forEach(const F &f)
                    {
                        f(m_repair);
                    }
 
                    bool operator==(const Hole &other) const;
 
                    bool operator!=(const Hole &other) const;
 
                    std::string toString() const;
 
                    friend std::ostream &operator<<(std::ostream &stream, const Hole &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;
 
                    Repair m_repair;
 
                    friend struct DataModel::Detail::Befriend<Hole>;
                };
 
 
                // 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);
 
                            std::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()) + "]" };
                            }
 
                            std::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);
 
                            std::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);
 
                            std::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);
 
                            std::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()) + "]" };
                            }
 
                            std::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);
 
                            std::optional<bool> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Enabled>;
                        };
 
 
                        // 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/Mode" };
 
                            static constexpr const char *name{ "Mode" };
 
                            static constexpr const char *description{
                                R"description(The reflection filter has two modes: Local and Global. Global mode is generally better at
removing outlier points in the point cloud, whereas Local mode preserves more 3D data on
thin objects far from the background.
 
Additionally, Local mode behaves slightly differently depending on the Engine used. With
Phase engine or Stripe engine, Local mode will process faster than Global mode and remove
more reflection artifacts. Also with Stripe engine, Local mode might reduce the number of
points resolved on shiny and reflective objects. With Omni engine, Local mode will reduce
the amount of artifacts in low projector signal regions, but might also reduce coverage on
surfaces with low projector signal.
 
It is advised to use the Cluster filter together with Local mode.
)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))
                                                 + " }"
                                             };
                            }
 
                            std::optional<ValueType> m_opt;
 
                            friend struct DataModel::Detail::Befriend<Mode>;
                        };
 
                        using Descendants = std::tuple<
                            Settings::Processing::Filters::Reflection::Removal::Enabled,
                            Settings::Processing::Filters::Reflection::Removal::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 Mode &mode() const
                        {
                            return m_mode;
                        }
 
                        Mode &mode()
                        {
                            return m_mode;
                        }
 
                        Removal &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::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::Mode>::value,
                                int>::type = 0>
                        const Settings::Processing::Filters::Reflection::Removal::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::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::Mode &get() const
                        {
                            return m_mode;
                        }
 
                        template<typename F>
                        void forEach(const F &f) const
                        {
                            f(m_enabled);
                            f(m_mode);
                        }
 
                        template<typename F>
                        void forEach(const F &f)
                        {
                            f(m_enabled);
                            f(m_mode);
                        }
 
                        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;
                        Mode m_mode;
 
                        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::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::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::Mode>::value,
                            int>::type = 0>
                    const Settings::Processing::Filters::Reflection::Removal::Mode &get() const
                    {
                        return m_removal.get<Settings::Processing::Filters::Reflection::Removal::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);
 
                            std::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()) + "]" };
                            }
 
                            std::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::Hole,
                    Settings::Processing::Filters::Hole::Repair,
                    Settings::Processing::Filters::Hole::Repair::Enabled,
                    Settings::Processing::Filters::Hole::Repair::HoleSize,
                    Settings::Processing::Filters::Hole::Repair::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::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;
                }
 
                const Hole &hole() const
                {
                    return m_hole;
                }
 
                Hole &hole()
                {
                    return m_hole;
                }
 
                Filters &set(const Hole &value)
                {
                    m_hole = value;
                    return *this;
                }
 
                Filters &set(const Hole::Repair &value)
                {
                    m_hole.set(value);
                    return *this;
                }
 
                Filters &set(const Hole::Repair::Enabled &value)
                {
                    m_hole.set(value);
                    return *this;
                }
 
                Filters &set(const Hole::Repair::HoleSize &value)
                {
                    m_hole.set(value);
                    return *this;
                }
 
                Filters &set(const Hole::Repair::Strictness &value)
                {
                    m_hole.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::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::Hole>::value, int>::type = 0>
                const Settings::Processing::Filters::Hole &get() const
                {
                    return m_hole;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Hole::Repair>::value, int>::
                        type = 0>
                const Settings::Processing::Filters::Hole::Repair &get() const
                {
                    return m_hole.get<Settings::Processing::Filters::Hole::Repair>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Hole::Repair::Enabled>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Hole::Repair::Enabled &get() const
                {
                    return m_hole.get<Settings::Processing::Filters::Hole::Repair::Enabled>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Hole::Repair::HoleSize>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Hole::Repair::HoleSize &get() const
                {
                    return m_hole.get<Settings::Processing::Filters::Hole::Repair::HoleSize>();
                }
 
                template<
                    typename T,
                    typename std::enable_if<
                        std::is_same<T, Settings::Processing::Filters::Hole::Repair::Strictness>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Hole::Repair::Strictness &get() const
                {
                    return m_hole.get<Settings::Processing::Filters::Hole::Repair::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::Mode>::value,
                        int>::type = 0>
                const Settings::Processing::Filters::Reflection::Removal::Mode &get() const
                {
                    return m_reflection.get<Settings::Processing::Filters::Reflection::Removal::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::Hole &get() const
                {
                    return m_hole;
                }
 
                template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
                const Settings::Processing::Filters::Noise &get() const
                {
                    return m_noise;
                }
 
                template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
                const Settings::Processing::Filters::Outlier &get() const
                {
                    return m_outlier;
                }
 
                template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
                const Settings::Processing::Filters::Reflection &get() const
                {
                    return m_reflection;
                }
 
                template<size_t i, typename std::enable_if<i == 6, 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_hole);
                    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_hole);
                    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;
                Hole m_hole;
                Noise m_noise;
                Outlier m_outlier;
                Reflection m_reflection;
                Smoothing m_smoothing;
 
                friend struct DataModel::Detail::Befriend<Filters>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Resampling
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                static constexpr const char *path{ "Processing/Resampling" };
 
                static constexpr const char *name{ "Resampling" };
 
                static constexpr const char *description{
                    R"description(Settings for changing the output resolution of the point cloud.
)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/Resampling/Mode" };
 
                    static constexpr const char *name{ "Mode" };
 
                    static constexpr const char *description{
                        R"description(Setting for upsampling or downsampling the point cloud data by some factor. This operation
is performed after all other processing has been completed.
 
Downsampling is used to reduce the number of points in the point cloud. This is done by
combining each 2x2 or 4x4 group of pixels in the original point cloud into one pixel in
a new point cloud. This downsample functionality is identical to the downsample method
on the PointCloud class. The averaging process reduces noise in the point cloud, but it
will not improve capture speed. To improve capture speed, consider using the subsampling
modes found in Settings/Sampling/Pixel.
 
Upsampling is used to increase the number of points in the point cloud. It is not possible
to upsample beyond the full resolution of the camera, so upsampling may only be used in
combination with the subsampling modes found in Settings/Sampling/Pixel. For example, one may
combine blueSubsample2x2 with upsample2x2 to obtain a point cloud that matches a full
resolution 2D capture, while retaining the speed benefits of capturing the point cloud with
blueSubsample2x2. Upsampling is achieved by expanding pixels in the original point cloud into
groups of 2x2 or 4x4 pixels in a new point cloud. Where possible, values are filled at the
new points based on an interpolation of the surrounding original points. The points in the
new point cloud that correspond to points in the original point cloud are left unchanged.
Note that upsampling will lead to four (upsample2x2) or sixteen (upsample4x4) times as many
pixels in the point cloud compared to no upsampling, so users should be aware of increased
computational cost related to copying and analyzing this data.
)description"
                    };
 
                    enum class ValueType
                    {
                        disabled,
                        downsample2x2,
                        downsample4x4,
                        upsample2x2,
                        upsample4x4
                    };
                    static const Mode disabled;      
                    static const Mode downsample2x2; 
                    static const Mode downsample4x4; 
                    static const Mode upsample2x2;   
                    static const Mode upsample4x4;   
 
                    static std::set<ValueType> validValues()
                    {
                        return { ValueType::disabled,
                                 ValueType::downsample2x2,
                                 ValueType::downsample4x4,
                                 ValueType::upsample2x2,
                                 ValueType::upsample4x4 };
                    }
 
                    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::disabled || value == ValueType::downsample2x2
                                       || value == ValueType::downsample4x4 || value == ValueType::upsample2x2
                                       || value == ValueType::upsample4x4
                                   ? value
                                   : throw std::invalid_argument{
                                         "Invalid value: Mode{ "
                                         + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value))
                                         + " }"
                                     };
                    }
 
                    std::optional<ValueType> m_opt;
 
                    friend struct DataModel::Detail::Befriend<Mode>;
                };
 
                using Descendants = std::tuple<Settings::Processing::Resampling::Mode>;
 
                Resampling();
 
#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 Resampling(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to Resampling(...). "
                        "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
                Resampling 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;
                }
 
                Resampling &set(const Mode &value)
                {
                    m_mode = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, Settings::Processing::Resampling::Mode>::value, int>::type =
                        0>
                const Settings::Processing::Resampling::Mode &get() const
                {
                    return m_mode;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const Settings::Processing::Resampling::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 Resampling &other) const;
 
                bool operator!=(const Resampling &other) const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Resampling &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<Resampling>;
            };
 
            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::Hole,
                Settings::Processing::Filters::Hole::Repair,
                Settings::Processing::Filters::Hole::Repair::Enabled,
                Settings::Processing::Filters::Hole::Repair::HoleSize,
                Settings::Processing::Filters::Hole::Repair::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::Mode,
                Settings::Processing::Filters::Smoothing,
                Settings::Processing::Filters::Smoothing::Gaussian,
                Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
                Settings::Processing::Filters::Smoothing::Gaussian::Sigma,
                Settings::Processing::Resampling,
                Settings::Processing::Resampling::Mode>;
 
            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::Hole &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Hole::Repair &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Hole::Repair::Enabled &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Hole::Repair::HoleSize &value)
            {
                m_filters.set(value);
                return *this;
            }
 
            Processing &set(const Filters::Hole::Repair::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::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;
            }
 
            const Resampling &resampling() const
            {
                return m_resampling;
            }
 
            Resampling &resampling()
            {
                return m_resampling;
            }
 
            Processing &set(const Resampling &value)
            {
                m_resampling = value;
                return *this;
            }
 
            Processing &set(const Resampling::Mode &value)
            {
                m_resampling.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::Hole>::value, int>::type = 0>
            const Settings::Processing::Filters::Hole &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Hole>();
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Hole::Repair>::value, int>::
                    type = 0>
            const Settings::Processing::Filters::Hole::Repair &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Hole::Repair>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Hole::Repair::Enabled>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Hole::Repair::Enabled &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Hole::Repair::Enabled>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Hole::Repair::HoleSize>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Hole::Repair::HoleSize &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Hole::Repair::HoleSize>();
            }
 
            template<
                typename T,
                typename std::enable_if<
                    std::is_same<T, Settings::Processing::Filters::Hole::Repair::Strictness>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Hole::Repair::Strictness &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Hole::Repair::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::Mode>::value,
                    int>::type = 0>
            const Settings::Processing::Filters::Reflection::Removal::Mode &get() const
            {
                return m_filters.get<Settings::Processing::Filters::Reflection::Removal::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<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Resampling>::value, int>::type = 0>
            const Settings::Processing::Resampling &get() const
            {
                return m_resampling;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, Settings::Processing::Resampling::Mode>::value, int>::type = 0>
            const Settings::Processing::Resampling::Mode &get() const
            {
                return m_resampling.get<Settings::Processing::Resampling::Mode>();
            }
 
            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<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const Settings::Processing::Resampling &get() const
            {
                return m_resampling;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_color);
                f(m_filters);
                f(m_resampling);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_color);
                f(m_filters);
                f(m_resampling);
            }
 
            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;
            Resampling m_resampling;
 
            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 points outside the given three-dimensional box.
 
Using this feature may significantly speed up acquisition and processing time, because
one can avoid acquiring and processing data that is guaranteed to fall outside of the
region of interest. The degree of speed-up depends on the size and shape of the box.
Generally, a smaller box yields a greater speed-up.
 
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(Enable or disable box 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);
 
                    std::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);
 
                    std::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);
 
                    std::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);
 
                    std::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);
 
                    std::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(Enable or disable depth 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);
 
                    std::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);
 
                    std::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 settings.
)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 point cloud. The `rgb` option gives a 2D image
with full colors. The `grayscale` option gives a grayscale (r=g=b) 2D image, which
can be acquired faster than full colors. The `disabled` option gives no colors and
can allow for even faster captures.
 
The `grayscale` option is not available on all camera models.
 
This setting is deprecated as of SDK 2.14. This setting will be removed in the next SDK major
version (SDK 3.0). The recommended way to do a 2D+3D capture is to set a `Settings2D` object
in the `Settings/Color` field. Tip: If you want to convert an existing settings.yml file to
the recommended API, you can import the .yml file into Zivid Studio and then re-export it to
.yml.
)description"
                };
 
                enum class ValueType
                {
                    rgb,
                    disabled,
                    grayscale
                };
                static const Color rgb;       
                static const Color disabled;  
                static const Color grayscale; 
 
                static std::set<ValueType> validValues()
                {
                    return { ValueType::rgb, ValueType::disabled, ValueType::grayscale };
                }
 
                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 == ValueType::grayscale
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Color{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                std::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(For Zivid 2/2+, this setting controls whether to read out the full image sensor and
use white projector light or to subsample pixels for specific color channels with
corresponding projector light. Picking a specific color channel can help reduce noise
and effects of ambient light - projecting blue light is recommended.
 
For Zivid 2+R, the user does not have to set the projection color and should only
consider whether to scale the resolution `by2x2` or `by4x4`. Both of these modes
will boost the signal strength by about 4x compared to `all`, so the user should
consider a corresponding reduction in exposure time.
 
Sampling at a decreased resolution decreases capture time, as less data will be captured and processed.
)description"
                };
 
                enum class ValueType
                {
                    all,
                    blueSubsample2x2,
                    redSubsample2x2,
                    blueSubsample4x4,
                    redSubsample4x4,
                    by2x2,
                    by4x4
                };
                static const Pixel all;              
                static const Pixel blueSubsample2x2; 
                static const Pixel redSubsample2x2;  
                static const Pixel blueSubsample4x4; 
                static const Pixel redSubsample4x4;  
                static const Pixel by2x2;            
                static const Pixel by4x4;            
 
                static std::set<ValueType> validValues()
                {
                    return { ValueType::all,
                             ValueType::blueSubsample2x2,
                             ValueType::redSubsample2x2,
                             ValueType::blueSubsample4x4,
                             ValueType::redSubsample4x4,
                             ValueType::by2x2,
                             ValueType::by4x4 };
                }
 
                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 == ValueType::blueSubsample4x4
                                   || value == ValueType::redSubsample4x4 || value == ValueType::by2x2
                                   || value == ValueType::by4x4
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Pixel{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                std::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::Color,
            Settings::Diagnostics,
            Settings::Diagnostics::Enabled,
            Settings::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::Hole,
            Settings::Processing::Filters::Hole::Repair,
            Settings::Processing::Filters::Hole::Repair::Enabled,
            Settings::Processing::Filters::Hole::Repair::HoleSize,
            Settings::Processing::Filters::Hole::Repair::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::Mode,
            Settings::Processing::Filters::Smoothing,
            Settings::Processing::Filters::Smoothing::Gaussian,
            Settings::Processing::Filters::Smoothing::Gaussian::Enabled,
            Settings::Processing::Filters::Smoothing::Gaussian::Sigma,
            Settings::Processing::Resampling,
            Settings::Processing::Resampling::Mode,
            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);
 
        [[nodiscard]] static Settings fromSerialized(const std::string &value);
 
        std::string serialize() const;
 
#ifndef NO_DOC
        template<
            typename... Args,
            typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
            typename std::enable_if<
                Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
                int>::type = 0>
#else
        template<typename... Args>
#endif
        explicit 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 Color &color() const
        {
            return m_color;
        }
 
        Color &color()
        {
            return m_color;
        }
 
        Settings &set(const Color &value)
        {
            m_color = 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 Engine &engine() const
        {
            return m_engine;
        }
 
        Engine &engine()
        {
            return m_engine;
        }
 
        Settings &set(const Engine &value)
        {
            m_engine = 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::Hole &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Hole::Repair &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Hole::Repair::Enabled &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Hole::Repair::HoleSize &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Filters::Hole::Repair::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::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;
        }
 
        Settings &set(const Processing::Resampling &value)
        {
            m_processing.set(value);
            return *this;
        }
 
        Settings &set(const Processing::Resampling::Mode &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::Color>::value, int>::type = 0>
        const Settings::Color &get() const
        {
            return m_color;
        }
 
        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::Engine>::value, int>::type = 0>
        const Settings::Engine &get() const
        {
            return m_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::Hole>::value, int>::type = 0>
        const Settings::Processing::Filters::Hole &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Hole>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Hole::Repair>::value, int>::type = 0>
        const Settings::Processing::Filters::Hole::Repair &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Hole::Repair>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Filters::Hole::Repair::Enabled>::value, int>::
                type = 0>
        const Settings::Processing::Filters::Hole::Repair::Enabled &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Hole::Repair::Enabled>();
        }
 
        template<
            typename T,
            typename std::
                enable_if<std::is_same<T, Settings::Processing::Filters::Hole::Repair::HoleSize>::value, int>::type = 0>
        const Settings::Processing::Filters::Hole::Repair::HoleSize &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Hole::Repair::HoleSize>();
        }
 
        template<
            typename T,
            typename std::enable_if<
                std::is_same<T, Settings::Processing::Filters::Hole::Repair::Strictness>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Hole::Repair::Strictness &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Hole::Repair::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::Mode>::value,
                int>::type = 0>
        const Settings::Processing::Filters::Reflection::Removal::Mode &get() const
        {
            return m_processing.get<Settings::Processing::Filters::Reflection::Removal::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::Processing::Resampling>::value, int>::type = 0>
        const Settings::Processing::Resampling &get() const
        {
            return m_processing.get<Settings::Processing::Resampling>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, Settings::Processing::Resampling::Mode>::value, int>::type = 0>
        const Settings::Processing::Resampling::Mode &get() const
        {
            return m_processing.get<Settings::Processing::Resampling::Mode>();
        }
 
        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::Color &get() const
        {
            return m_color;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const Settings::Diagnostics &get() const
        {
            return m_diagnostics;
        }
 
        template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
        const Settings::Engine &get() const
        {
            return m_engine;
        }
 
        template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
        const Settings::Processing &get() const
        {
            return m_processing;
        }
 
        template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
        const Settings::RegionOfInterest &get() const
        {
            return m_regionOfInterest;
        }
 
        template<size_t i, typename std::enable_if<i == 6, 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_color);
            f(m_diagnostics);
            f(m_engine);
            f(m_processing);
            f(m_regionOfInterest);
            f(m_sampling);
        }
 
        template<typename F>
        void forEach(const F &f)
        {
            f(m_acquisitions);
            f(m_color);
            f(m_diagnostics);
            f(m_engine);
            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;
        Color m_color;
        Diagnostics m_diagnostics;
        Engine m_engine;
        Processing m_processing;
        RegionOfInterest m_regionOfInterest;
        Sampling m_sampling;
 
        friend struct DataModel::Detail::Befriend<Settings>;
    };
 
#ifndef NO_DOC
    template<>
    struct Settings::Version<27>
    {
        using Type = Settings;
    };
#endif
 
} // namespace Zivid
 
#ifndef NO_DOC
namespace Zivid::Detail
{
 
    ZIVID_CORE_EXPORT void save(const Zivid::Settings &dataModel, std::ostream &ostream);
    ZIVID_CORE_EXPORT void load(Zivid::Settings &dataModel, std::istream &istream);
 
    ZIVID_CORE_EXPORT std::vector<uint8_t> serializeToBinaryVector(const Zivid::Settings &source);
    ZIVID_CORE_EXPORT void deserializeFromBinaryVector(Zivid::Settings &dest, const std::vector<uint8_t> &data);
 
} // namespace Zivid::Detail
#endif
 
#ifdef _MSC_VER
#    pragma warning(pop)
#endif
 
#ifndef NO_DOC
#    if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
namespace std // NOLINT
{
 
    template<>
    struct tuple_size<Zivid::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::Processing> : integral_constant<size_t, 3>
    {};
 
    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 3");
 
        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, 7>
    {};
 
    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 7");
 
        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, 1>
    {};
 
    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 1");
 
        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::Hole> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Hole>
    {
        static_assert(i < tuple_size<Zivid::Settings::Processing::Filters::Hole>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Hole>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::Settings::Processing::Filters::Hole::Repair> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Filters::Hole::Repair>
    {
        static_assert(
            i < tuple_size<Zivid::Settings::Processing::Filters::Hole::Repair>::value,
            "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Filters::Hole::Repair>().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::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::Processing::Resampling> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings::Processing::Resampling>
    {
        static_assert(i < tuple_size<Zivid::Settings::Processing::Resampling>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::Settings::Processing::Resampling>().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, 7>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::Settings>
    {
        static_assert(i < tuple_size<Zivid::Settings>::value, "Index must be less than 7");
 
        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