// WARNING: Please don't edit this file. It was generated by Python/WinRT v2.3.0

#include "py.Windows.Devices.Perception.Provider.h"

namespace py::cpp::Windows::Devices::Perception::Provider
{
    // ----- KnownPerceptionFrameKind class --------------------

    static PyObject* _new_KnownPerceptionFrameKind(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind>::type_name);
        return nullptr;
    }

    static PyObject* KnownPerceptionFrameKind_get_Color(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.KnownPerceptionFrameKind", L"Color");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind::Color());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownPerceptionFrameKind_get_Depth(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.KnownPerceptionFrameKind", L"Depth");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind::Depth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownPerceptionFrameKind_get_Infrared(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.KnownPerceptionFrameKind", L"Infrared");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind::Infrared());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_KnownPerceptionFrameKind[] = {
        { }
    };

    static PyGetSetDef _getset_KnownPerceptionFrameKind[] = {
        { }
    };

    static PyType_Slot _type_slots_KnownPerceptionFrameKind[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_KnownPerceptionFrameKind) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_KnownPerceptionFrameKind) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_KnownPerceptionFrameKind) },
        { }
    };

    static PyType_Spec type_spec_KnownPerceptionFrameKind = {
        "winrt._winrt_windows_devices_perception_provider.KnownPerceptionFrameKind",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_KnownPerceptionFrameKind};

    static PyGetSetDef getset_KnownPerceptionFrameKind_Static[] = {
        { "color", reinterpret_cast<getter>(KnownPerceptionFrameKind_get_Color), nullptr, nullptr, nullptr },
        { "depth", reinterpret_cast<getter>(KnownPerceptionFrameKind_get_Depth), nullptr, nullptr, nullptr },
        { "infrared", reinterpret_cast<getter>(KnownPerceptionFrameKind_get_Infrared), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_KnownPerceptionFrameKind_Static[] = {
        { }
    };

    static PyType_Slot type_slots_KnownPerceptionFrameKind_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_KnownPerceptionFrameKind_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_KnownPerceptionFrameKind_Static) },
        { }
    };

    static PyType_Spec type_spec_KnownPerceptionFrameKind_Static =
    {
        "winrt._winrt_windows_devices_perception_provider.KnownPerceptionFrameKind_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_KnownPerceptionFrameKind_Static
    };

    // ----- PerceptionControlGroup class --------------------

    static PyObject* _new_PerceptionControlGroup(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::hstring>>(args, 0);

                winrt::Windows::Devices::Perception::Provider::PerceptionControlGroup instance{param0};
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_PerceptionControlGroup(py::wrapper::Windows::Devices::Perception::Provider::PerceptionControlGroup* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionControlGroup_get_FrameProviderIds(py::wrapper::Windows::Devices::Perception::Provider::PerceptionControlGroup* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionControlGroup", L"FrameProviderIds");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.FrameProviderIds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PerceptionControlGroup(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionControlGroup>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionControlGroup(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionControlGroup>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionControlGroup[] = {
        { "_assign_array_", _assign_array_PerceptionControlGroup, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionControlGroup), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionControlGroup[] = {
        { "frame_provider_ids", reinterpret_cast<getter>(PerceptionControlGroup_get_FrameProviderIds), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PerceptionControlGroup[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionControlGroup) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionControlGroup) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionControlGroup) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionControlGroup) },
        { }
    };

    static PyType_Spec type_spec_PerceptionControlGroup = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionControlGroup",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionControlGroup),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionControlGroup};

    // ----- PerceptionCorrelation class --------------------

    static PyObject* _new_PerceptionCorrelation(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Numerics::float3>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Numerics::quaternion>(args, 2);

                winrt::Windows::Devices::Perception::Provider::PerceptionCorrelation instance{param0, param1, param2};
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_PerceptionCorrelation(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelation* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionCorrelation_get_Orientation(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelation* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionCorrelation", L"Orientation");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PerceptionCorrelation_get_Position(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelation* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionCorrelation", L"Position");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Position());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PerceptionCorrelation_get_TargetId(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelation* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionCorrelation", L"TargetId");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.TargetId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PerceptionCorrelation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelation>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionCorrelation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionCorrelation[] = {
        { "_assign_array_", _assign_array_PerceptionCorrelation, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionCorrelation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionCorrelation[] = {
        { "orientation", reinterpret_cast<getter>(PerceptionCorrelation_get_Orientation), nullptr, nullptr, nullptr },
        { "position", reinterpret_cast<getter>(PerceptionCorrelation_get_Position), nullptr, nullptr, nullptr },
        { "target_id", reinterpret_cast<getter>(PerceptionCorrelation_get_TargetId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PerceptionCorrelation[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionCorrelation) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionCorrelation) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionCorrelation) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionCorrelation) },
        { }
    };

    static PyType_Spec type_spec_PerceptionCorrelation = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionCorrelation",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionCorrelation};

    // ----- PerceptionCorrelationGroup class --------------------

    static PyObject* _new_PerceptionCorrelationGroup(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelation>>(args, 0);

                winrt::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup instance{param0};
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_PerceptionCorrelationGroup(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionCorrelationGroup_get_RelativeLocations(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionCorrelationGroup", L"RelativeLocations");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.RelativeLocations());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PerceptionCorrelationGroup(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionCorrelationGroup(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionCorrelationGroup[] = {
        { "_assign_array_", _assign_array_PerceptionCorrelationGroup, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionCorrelationGroup), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionCorrelationGroup[] = {
        { "relative_locations", reinterpret_cast<getter>(PerceptionCorrelationGroup_get_RelativeLocations), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PerceptionCorrelationGroup[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionCorrelationGroup) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionCorrelationGroup) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionCorrelationGroup) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionCorrelationGroup) },
        { }
    };

    static PyType_Spec type_spec_PerceptionCorrelationGroup = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionCorrelationGroup",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionCorrelationGroup};

    // ----- PerceptionFaceAuthenticationGroup class --------------------

    static PyObject* _new_PerceptionFaceAuthenticationGroup(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::hstring>>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionStartFaceAuthenticationHandler>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionStopFaceAuthenticationHandler>(args, 2);

                winrt::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup instance{param0, param1, param2};
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_PerceptionFaceAuthenticationGroup(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionFaceAuthenticationGroup_get_FrameProviderIds(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup", L"FrameProviderIds");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.FrameProviderIds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PerceptionFaceAuthenticationGroup(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionFaceAuthenticationGroup(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionFaceAuthenticationGroup[] = {
        { "_assign_array_", _assign_array_PerceptionFaceAuthenticationGroup, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionFaceAuthenticationGroup), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionFaceAuthenticationGroup[] = {
        { "frame_provider_ids", reinterpret_cast<getter>(PerceptionFaceAuthenticationGroup_get_FrameProviderIds), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PerceptionFaceAuthenticationGroup[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionFaceAuthenticationGroup) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionFaceAuthenticationGroup) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionFaceAuthenticationGroup) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionFaceAuthenticationGroup) },
        { }
    };

    static PyType_Spec type_spec_PerceptionFaceAuthenticationGroup = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionFaceAuthenticationGroup",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionFaceAuthenticationGroup};

    // ----- PerceptionFrame class --------------------

    static PyObject* _new_PerceptionFrame(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrame>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrame>::type_name);
        return nullptr;
    }

    static void _dealloc_PerceptionFrame(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionFrame_get_RelativeTime(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrame", L"RelativeTime");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.RelativeTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerceptionFrame_put_RelativeTime(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrame", L"RelativeTime");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<winrt::Windows::Foundation::TimeSpan>(arg);

            self->obj.RelativeTime(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerceptionFrame_get_FrameData(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrame", L"FrameData");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.FrameData());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PerceptionFrame_get_Properties(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrame", L"Properties");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Properties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PerceptionFrame(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionFrame>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionFrame(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionFrame>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionFrame[] = {
        { "_assign_array_", _assign_array_PerceptionFrame, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionFrame), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionFrame[] = {
        { "relative_time", reinterpret_cast<getter>(PerceptionFrame_get_RelativeTime), reinterpret_cast<setter>(PerceptionFrame_put_RelativeTime), nullptr, nullptr },
        { "frame_data", reinterpret_cast<getter>(PerceptionFrame_get_FrameData), nullptr, nullptr, nullptr },
        { "properties", reinterpret_cast<getter>(PerceptionFrame_get_Properties), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PerceptionFrame[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionFrame) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionFrame) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionFrame) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionFrame) },
        { }
    };

    static PyType_Spec type_spec_PerceptionFrame = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionFrame",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionFrame};

    // ----- PerceptionFrameProviderInfo class --------------------

    static PyObject* _new_PerceptionFrameProviderInfo(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo instance{};
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_PerceptionFrameProviderInfo(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionFrameProviderInfo_get_Id(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"Id");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerceptionFrameProviderInfo_put_Id(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"Id");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Id(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerceptionFrameProviderInfo_get_Hidden(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"Hidden");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Hidden());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerceptionFrameProviderInfo_put_Hidden(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"Hidden");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<bool>(arg);

            self->obj.Hidden(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerceptionFrameProviderInfo_get_FrameKind(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"FrameKind");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.FrameKind());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerceptionFrameProviderInfo_put_FrameKind(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"FrameKind");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.FrameKind(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerceptionFrameProviderInfo_get_DisplayName(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"DisplayName");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerceptionFrameProviderInfo_put_DisplayName(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"DisplayName");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.DisplayName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerceptionFrameProviderInfo_get_DeviceKind(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"DeviceKind");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.DeviceKind());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerceptionFrameProviderInfo_put_DeviceKind(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo", L"DeviceKind");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.DeviceKind(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_PerceptionFrameProviderInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionFrameProviderInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionFrameProviderInfo[] = {
        { "_assign_array_", _assign_array_PerceptionFrameProviderInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionFrameProviderInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionFrameProviderInfo[] = {
        { "id", reinterpret_cast<getter>(PerceptionFrameProviderInfo_get_Id), reinterpret_cast<setter>(PerceptionFrameProviderInfo_put_Id), nullptr, nullptr },
        { "hidden", reinterpret_cast<getter>(PerceptionFrameProviderInfo_get_Hidden), reinterpret_cast<setter>(PerceptionFrameProviderInfo_put_Hidden), nullptr, nullptr },
        { "frame_kind", reinterpret_cast<getter>(PerceptionFrameProviderInfo_get_FrameKind), reinterpret_cast<setter>(PerceptionFrameProviderInfo_put_FrameKind), nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(PerceptionFrameProviderInfo_get_DisplayName), reinterpret_cast<setter>(PerceptionFrameProviderInfo_put_DisplayName), nullptr, nullptr },
        { "device_kind", reinterpret_cast<getter>(PerceptionFrameProviderInfo_get_DeviceKind), reinterpret_cast<setter>(PerceptionFrameProviderInfo_put_DeviceKind), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PerceptionFrameProviderInfo[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionFrameProviderInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionFrameProviderInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionFrameProviderInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionFrameProviderInfo) },
        { }
    };

    static PyType_Spec type_spec_PerceptionFrameProviderInfo = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionFrameProviderInfo",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionFrameProviderInfo};

    // ----- PerceptionFrameProviderManagerService class --------------------

    static PyObject* _new_PerceptionFrameProviderManagerService(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService>::type_name);
        return nullptr;
    }

    static PyObject* PerceptionFrameProviderManagerService_PublishFrameForProvider(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"PublishFrameForProvider", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionFrame>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::PublishFrameForProvider(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_RegisterControlGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"RegisterControlGroup", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionControlGroup>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::RegisterControlGroup(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_RegisterCorrelationGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"RegisterCorrelationGroup", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::RegisterCorrelationGroup(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_RegisterFaceAuthenticationGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"RegisterFaceAuthenticationGroup", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::RegisterFaceAuthenticationGroup(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_RegisterFrameProviderInfo(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"RegisterFrameProviderInfo", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::RegisterFrameProviderInfo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_UnregisterControlGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"UnregisterControlGroup", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionControlGroup>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::UnregisterControlGroup(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_UnregisterCorrelationGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"UnregisterCorrelationGroup", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::UnregisterCorrelationGroup(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_UnregisterFaceAuthenticationGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"UnregisterFaceAuthenticationGroup", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::UnregisterFaceAuthenticationGroup(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_UnregisterFrameProviderInfo(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"UnregisterFrameProviderInfo", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::UnregisterFrameProviderInfo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionFrameProviderManagerService_UpdateAvailabilityForProvider(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionFrameProviderManagerService", L"UpdateAvailabilityForProvider", 2);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(2);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService::UpdateAvailabilityForProvider(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionFrameProviderManagerService[] = {
        { }
    };

    static PyGetSetDef _getset_PerceptionFrameProviderManagerService[] = {
        { }
    };

    static PyType_Slot _type_slots_PerceptionFrameProviderManagerService[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionFrameProviderManagerService) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionFrameProviderManagerService) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionFrameProviderManagerService) },
        { }
    };

    static PyType_Spec type_spec_PerceptionFrameProviderManagerService = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionFrameProviderManagerService",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionFrameProviderManagerService};

    static PyGetSetDef getset_PerceptionFrameProviderManagerService_Static[] = {
        { }
    };

    static PyMethodDef methods_PerceptionFrameProviderManagerService_Static[] = {
        { "publish_frame_for_provider", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_PublishFrameForProvider), METH_VARARGS, nullptr },
        { "register_control_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterControlGroup), METH_VARARGS, nullptr },
        { "register_correlation_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterCorrelationGroup), METH_VARARGS, nullptr },
        { "register_face_authentication_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterFaceAuthenticationGroup), METH_VARARGS, nullptr },
        { "register_frame_provider_info", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterFrameProviderInfo), METH_VARARGS, nullptr },
        { "unregister_control_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterControlGroup), METH_VARARGS, nullptr },
        { "unregister_correlation_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterCorrelationGroup), METH_VARARGS, nullptr },
        { "unregister_face_authentication_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterFaceAuthenticationGroup), METH_VARARGS, nullptr },
        { "unregister_frame_provider_info", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterFrameProviderInfo), METH_VARARGS, nullptr },
        { "update_availability_for_provider", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UpdateAvailabilityForProvider), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_PerceptionFrameProviderManagerService_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PerceptionFrameProviderManagerService_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PerceptionFrameProviderManagerService_Static) },
        { }
    };

    static PyType_Spec type_spec_PerceptionFrameProviderManagerService_Static =
    {
        "winrt._winrt_windows_devices_perception_provider.PerceptionFrameProviderManagerService_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PerceptionFrameProviderManagerService_Static
    };

    // ----- PerceptionPropertyChangeRequest class --------------------

    static PyObject* _new_PerceptionPropertyChangeRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_PerceptionPropertyChangeRequest(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionPropertyChangeRequest_GetDeferral(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionPropertyChangeRequest", L"GetDeferral", 0);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(0);
                    return nullptr;
                }

                return py::convert(self->obj.GetDeferral());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionPropertyChangeRequest_get_Status(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionPropertyChangeRequest", L"Status");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PerceptionPropertyChangeRequest_put_Status(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionPropertyChangeRequest", L"Status");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return -1;
            }

            auto param0 = py::convert_to<winrt::Windows::Devices::Perception::PerceptionFrameSourcePropertyChangeStatus>(arg);

            self->obj.Status(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PerceptionPropertyChangeRequest_get_Name(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionPropertyChangeRequest", L"Name");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PerceptionPropertyChangeRequest_get_Value(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.PerceptionPropertyChangeRequest", L"Value");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Value());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PerceptionPropertyChangeRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionPropertyChangeRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionPropertyChangeRequest[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(PerceptionPropertyChangeRequest_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PerceptionPropertyChangeRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionPropertyChangeRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionPropertyChangeRequest[] = {
        { "status", reinterpret_cast<getter>(PerceptionPropertyChangeRequest_get_Status), reinterpret_cast<setter>(PerceptionPropertyChangeRequest_put_Status), nullptr, nullptr },
        { "name", reinterpret_cast<getter>(PerceptionPropertyChangeRequest_get_Name), nullptr, nullptr, nullptr },
        { "value", reinterpret_cast<getter>(PerceptionPropertyChangeRequest_get_Value), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PerceptionPropertyChangeRequest[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionPropertyChangeRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionPropertyChangeRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionPropertyChangeRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionPropertyChangeRequest) },
        { }
    };

    static PyType_Spec type_spec_PerceptionPropertyChangeRequest = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionPropertyChangeRequest",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionPropertyChangeRequest};

    // ----- PerceptionVideoFrameAllocator class --------------------

    static PyObject* _new_PerceptionVideoFrameAllocator(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 4)
        {
            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Graphics::Imaging::BitmapPixelFormat>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Size>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Graphics::Imaging::BitmapAlphaMode>(args, 3);

                winrt::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator instance{param0, param1, param2, param3};
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_PerceptionVideoFrameAllocator(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PerceptionVideoFrameAllocator_AllocateFrame(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionVideoFrameAllocator", L"AllocateFrame", 0);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(0);
                    return nullptr;
                }

                return py::convert(self->obj.AllocateFrame());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionVideoFrameAllocator_Close(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionVideoFrameAllocator", L"Close", 0);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(0);
                    return nullptr;
                }

                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PerceptionVideoFrameAllocator_CopyFromVideoFrame(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.PerceptionVideoFrameAllocator", L"CopyFromVideoFrame", 1);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(1);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Media::VideoFrame>(args, 0);

                return py::convert(self->obj.CopyFromVideoFrame(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_PerceptionVideoFrameAllocator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PerceptionVideoFrameAllocator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_PerceptionVideoFrameAllocator(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_PerceptionVideoFrameAllocator(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PerceptionVideoFrameAllocator[] = {
        { "allocate_frame", reinterpret_cast<PyCFunction>(PerceptionVideoFrameAllocator_AllocateFrame), METH_VARARGS, nullptr },
        { "close", reinterpret_cast<PyCFunction>(PerceptionVideoFrameAllocator_Close), METH_VARARGS, nullptr },
        { "copy_from_video_frame", reinterpret_cast<PyCFunction>(PerceptionVideoFrameAllocator_CopyFromVideoFrame), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PerceptionVideoFrameAllocator, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PerceptionVideoFrameAllocator), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_PerceptionVideoFrameAllocator), METH_NOARGS, nullptr },
        { "__exit__", reinterpret_cast<PyCFunction>(_exit_PerceptionVideoFrameAllocator), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionVideoFrameAllocator[] = {
        { }
    };

    static PyType_Slot _type_slots_PerceptionVideoFrameAllocator[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_PerceptionVideoFrameAllocator) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PerceptionVideoFrameAllocator) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PerceptionVideoFrameAllocator) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PerceptionVideoFrameAllocator) },
        { }
    };

    static PyType_Spec type_spec_PerceptionVideoFrameAllocator = {
        "winrt._winrt_windows_devices_perception_provider.PerceptionVideoFrameAllocator",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionVideoFrameAllocator};

    // ----- IPerceptionFrameProvider interface --------------------

    static PyObject* _new_IPerceptionFrameProvider(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>::type_name);
        return nullptr;
    }

    static void _dealloc_IPerceptionFrameProvider(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IPerceptionFrameProvider_Close(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Foundation.IClosable", L"Close", 0);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(0);
                    return nullptr;
                }

                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IPerceptionFrameProvider_SetProperty(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.IPerceptionFrameProvider", L"SetProperty", 1);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(1);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest>(args, 0);

                self->obj.SetProperty(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IPerceptionFrameProvider_Start(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.IPerceptionFrameProvider", L"Start", 0);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(0);
                    return nullptr;
                }

                self->obj.Start();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IPerceptionFrameProvider_Stop(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.IPerceptionFrameProvider", L"Stop", 0);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(0);
                    return nullptr;
                }

                self->obj.Stop();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IPerceptionFrameProvider_get_Available(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.IPerceptionFrameProvider", L"Available");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Available());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IPerceptionFrameProvider_get_FrameProviderInfo(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.IPerceptionFrameProvider", L"FrameProviderInfo");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.FrameProviderInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IPerceptionFrameProvider_get_Properties(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, void* /*unused*/) noexcept
    {
        try
        {
            static std::optional<bool> is_property_present{};

            if (!is_property_present.has_value())
            {
                is_property_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Perception.Provider.IPerceptionFrameProvider", L"Properties");
            }

            if (!is_property_present.value())
            {
                PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
                return nullptr;
            }

            return py::convert(self->obj.Properties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_IPerceptionFrameProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IPerceptionFrameProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_IPerceptionFrameProvider(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_IPerceptionFrameProvider(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IPerceptionFrameProvider[] = {
        { "close", reinterpret_cast<PyCFunction>(IPerceptionFrameProvider_Close), METH_VARARGS, nullptr },
        { "set_property", reinterpret_cast<PyCFunction>(IPerceptionFrameProvider_SetProperty), METH_VARARGS, nullptr },
        { "start", reinterpret_cast<PyCFunction>(IPerceptionFrameProvider_Start), METH_VARARGS, nullptr },
        { "stop", reinterpret_cast<PyCFunction>(IPerceptionFrameProvider_Stop), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IPerceptionFrameProvider, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IPerceptionFrameProvider), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_IPerceptionFrameProvider), METH_NOARGS, nullptr },
        { "__exit__", reinterpret_cast<PyCFunction>(_exit_IPerceptionFrameProvider), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_IPerceptionFrameProvider[] = {
        { "available", reinterpret_cast<getter>(IPerceptionFrameProvider_get_Available), nullptr, nullptr, nullptr },
        { "frame_provider_info", reinterpret_cast<getter>(IPerceptionFrameProvider_get_FrameProviderInfo), nullptr, nullptr, nullptr },
        { "properties", reinterpret_cast<getter>(IPerceptionFrameProvider_get_Properties), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IPerceptionFrameProvider[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_IPerceptionFrameProvider) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IPerceptionFrameProvider) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IPerceptionFrameProvider) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IPerceptionFrameProvider) },
        { }
    };

    static PyType_Spec type_spec_IPerceptionFrameProvider = {
        "winrt._winrt_windows_devices_perception_provider.IPerceptionFrameProvider",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IPerceptionFrameProvider};

    // ----- IPerceptionFrameProviderManager interface --------------------

    static PyObject* _new_IPerceptionFrameProviderManager(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>::type_name);
        return nullptr;
    }

    static void _dealloc_IPerceptionFrameProviderManager(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IPerceptionFrameProviderManager_Close(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Foundation.IClosable", L"Close", 0);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(0);
                    return nullptr;
                }

                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IPerceptionFrameProviderManager_GetFrameProvider(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                static std::optional<bool> is_overload_present{};

                if (!is_overload_present.has_value())
                {
                    is_overload_present = winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager", L"GetFrameProvider", 1);
                }

                if (!is_overload_present.value())
                {
                    py::set_arg_count_version_error(1);
                    return nullptr;
                }

                auto param0 = py::convert_to<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo>(args, 0);

                return py::convert(self->obj.GetFrameProvider(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_IPerceptionFrameProviderManager(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IPerceptionFrameProviderManager(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_IPerceptionFrameProviderManager(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_IPerceptionFrameProviderManager(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IPerceptionFrameProviderManager[] = {
        { "close", reinterpret_cast<PyCFunction>(IPerceptionFrameProviderManager_Close), METH_VARARGS, nullptr },
        { "get_frame_provider", reinterpret_cast<PyCFunction>(IPerceptionFrameProviderManager_GetFrameProvider), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IPerceptionFrameProviderManager, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IPerceptionFrameProviderManager), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_IPerceptionFrameProviderManager), METH_NOARGS, nullptr },
        { "__exit__", reinterpret_cast<PyCFunction>(_exit_IPerceptionFrameProviderManager), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_IPerceptionFrameProviderManager[] = {
        { }
    };

    static PyType_Slot _type_slots_IPerceptionFrameProviderManager[] = {
        { Py_tp_new, reinterpret_cast<void*>(_new_IPerceptionFrameProviderManager) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IPerceptionFrameProviderManager) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IPerceptionFrameProviderManager) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IPerceptionFrameProviderManager) },
        { }
    };

    static PyType_Spec type_spec_IPerceptionFrameProviderManager = {
        "winrt._winrt_windows_devices_perception_provider.IPerceptionFrameProviderManager",
        sizeof(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IPerceptionFrameProviderManager};

    // ----- Windows.Devices.Perception.Provider Initialization --------------------

    PyDoc_STRVAR(module_doc, "Windows.Devices.Perception.Provider");

    static PyModuleDef module_def = {
        PyModuleDef_HEAD_INIT,
        "_winrt_windows_devices_perception_provider",
        module_doc,
        0,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        nullptr};
} // py::cpp::Windows::Devices::Perception::Provider

PyMODINIT_FUNC PyInit__winrt_windows_devices_perception_provider(void) noexcept
{
    using namespace py::cpp::Windows::Devices::Perception::Provider;

    if (py::import_winrt_runtime() == -1)
    {
        return nullptr;
    }

    py::pyobj_handle module{PyModule_Create(&module_def)};

    if (!module)
    {
        return nullptr;
    }

    auto object_type = py::get_object_type();
    if (!object_type)
    {
        return nullptr;
    }

    py::pyobj_handle object_bases{PyTuple_Pack(1, object_type)};

    if (!object_bases)
    {
        return nullptr;
    }

    py::pyobj_handle type_KnownPerceptionFrameKind_Static{PyType_FromSpec(&type_spec_KnownPerceptionFrameKind_Static)};
    if (!type_KnownPerceptionFrameKind_Static)
    {
        return nullptr;
    }

    py::pytype_handle KnownPerceptionFrameKind_type{py::register_python_type(module.get(), &type_spec_KnownPerceptionFrameKind, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_KnownPerceptionFrameKind_Static.get()))};
    if (!KnownPerceptionFrameKind_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionControlGroup_type{py::register_python_type(module.get(), &type_spec_PerceptionControlGroup, object_bases.get(), nullptr)};
    if (!PerceptionControlGroup_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionCorrelation_type{py::register_python_type(module.get(), &type_spec_PerceptionCorrelation, object_bases.get(), nullptr)};
    if (!PerceptionCorrelation_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionCorrelationGroup_type{py::register_python_type(module.get(), &type_spec_PerceptionCorrelationGroup, object_bases.get(), nullptr)};
    if (!PerceptionCorrelationGroup_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionFaceAuthenticationGroup_type{py::register_python_type(module.get(), &type_spec_PerceptionFaceAuthenticationGroup, object_bases.get(), nullptr)};
    if (!PerceptionFaceAuthenticationGroup_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionFrame_type{py::register_python_type(module.get(), &type_spec_PerceptionFrame, object_bases.get(), nullptr)};
    if (!PerceptionFrame_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionFrameProviderInfo_type{py::register_python_type(module.get(), &type_spec_PerceptionFrameProviderInfo, object_bases.get(), nullptr)};
    if (!PerceptionFrameProviderInfo_type)
    {
        return nullptr;
    }

    py::pyobj_handle type_PerceptionFrameProviderManagerService_Static{PyType_FromSpec(&type_spec_PerceptionFrameProviderManagerService_Static)};
    if (!type_PerceptionFrameProviderManagerService_Static)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionFrameProviderManagerService_type{py::register_python_type(module.get(), &type_spec_PerceptionFrameProviderManagerService, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PerceptionFrameProviderManagerService_Static.get()))};
    if (!PerceptionFrameProviderManagerService_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionPropertyChangeRequest_type{py::register_python_type(module.get(), &type_spec_PerceptionPropertyChangeRequest, object_bases.get(), nullptr)};
    if (!PerceptionPropertyChangeRequest_type)
    {
        return nullptr;
    }

    py::pytype_handle PerceptionVideoFrameAllocator_type{py::register_python_type(module.get(), &type_spec_PerceptionVideoFrameAllocator, object_bases.get(), nullptr)};
    if (!PerceptionVideoFrameAllocator_type)
    {
        return nullptr;
    }

    py::pytype_handle IPerceptionFrameProvider_type{py::register_python_type(module.get(), &type_spec_IPerceptionFrameProvider, object_bases.get(), nullptr)};
    if (!IPerceptionFrameProvider_type)
    {
        return nullptr;
    }

    py::pytype_handle IPerceptionFrameProviderManager_type{py::register_python_type(module.get(), &type_spec_IPerceptionFrameProviderManager, object_bases.get(), nullptr)};
    if (!IPerceptionFrameProviderManager_type)
    {
        return nullptr;
    }


    return module.detach();
}
