// WARNING: Please don't edit this file. It was generated by Python/WinRT v1.0.0-beta.2

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

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionControlGroup>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrame>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>::python_type;

namespace py::cpp::Windows::Devices::Perception::Provider
{
    // ----- KnownPerceptionFrameKind class --------------------
    constexpr const char* const _type_name_KnownPerceptionFrameKind = "KnownPerceptionFrameKind";

    static PyObject* _new_KnownPerceptionFrameKind(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_KnownPerceptionFrameKind);
        return nullptr;
    }

    static PyObject* KnownPerceptionFrameKind_get_Color(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            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
        {
            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
        {
            return py::convert(winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind::Infrared());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_KnownPerceptionFrameKind[] = {
        { "get_color", reinterpret_cast<PyCFunction>(KnownPerceptionFrameKind_get_Color), METH_NOARGS | METH_STATIC, nullptr },
        { "get_depth", reinterpret_cast<PyCFunction>(KnownPerceptionFrameKind_get_Depth), METH_NOARGS | METH_STATIC, nullptr },
        { "get_infrared", reinterpret_cast<PyCFunction>(KnownPerceptionFrameKind_get_Infrared), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_KnownPerceptionFrameKind[] = {
        { }
    };

    static PyType_Slot _type_slots_KnownPerceptionFrameKind[] = 
    {
        { Py_tp_new, _new_KnownPerceptionFrameKind },
        { Py_tp_methods, _methods_KnownPerceptionFrameKind },
        { Py_tp_getset, _getset_KnownPerceptionFrameKind },
        { },
    };

    static PyType_Spec _type_spec_KnownPerceptionFrameKind =
    {
        "_winsdk_Windows_Devices_Perception_Provider.KnownPerceptionFrameKind",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_KnownPerceptionFrameKind
    };

    // ----- PerceptionControlGroup class --------------------
    constexpr const char* const _type_name_PerceptionControlGroup = "PerceptionControlGroup";

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

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* PerceptionControlGroup_get_FrameProviderIds(py::wrapper::Windows::Devices::Perception::Provider::PerceptionControlGroup* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FrameProviderIds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_PerceptionControlGroup },
        { Py_tp_dealloc, _dealloc_PerceptionControlGroup },
        { Py_tp_methods, _methods_PerceptionControlGroup },
        { Py_tp_getset, _getset_PerceptionControlGroup },
        { },
    };

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

    // ----- PerceptionCorrelation class --------------------
    constexpr const char* const _type_name_PerceptionCorrelation = "PerceptionCorrelation";

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

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* PerceptionCorrelation_get_Orientation(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelation* self, void* /*unused*/) noexcept
    {
        try
        {
            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
        {
            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
        {
            return py::convert(self->obj.TargetId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_PerceptionCorrelation },
        { Py_tp_dealloc, _dealloc_PerceptionCorrelation },
        { Py_tp_methods, _methods_PerceptionCorrelation },
        { Py_tp_getset, _getset_PerceptionCorrelation },
        { },
    };

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

    // ----- PerceptionCorrelationGroup class --------------------
    constexpr const char* const _type_name_PerceptionCorrelationGroup = "PerceptionCorrelationGroup";

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

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* PerceptionCorrelationGroup_get_RelativeLocations(py::wrapper::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RelativeLocations());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_PerceptionCorrelationGroup },
        { Py_tp_dealloc, _dealloc_PerceptionCorrelationGroup },
        { Py_tp_methods, _methods_PerceptionCorrelationGroup },
        { Py_tp_getset, _getset_PerceptionCorrelationGroup },
        { },
    };

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

    // ----- PerceptionFaceAuthenticationGroup class --------------------
    constexpr const char* const _type_name_PerceptionFaceAuthenticationGroup = "PerceptionFaceAuthenticationGroup";

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

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* PerceptionFaceAuthenticationGroup_get_FrameProviderIds(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FrameProviderIds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_PerceptionFaceAuthenticationGroup },
        { Py_tp_dealloc, _dealloc_PerceptionFaceAuthenticationGroup },
        { Py_tp_methods, _methods_PerceptionFaceAuthenticationGroup },
        { Py_tp_getset, _getset_PerceptionFaceAuthenticationGroup },
        { },
    };

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

    // ----- PerceptionFrame class --------------------
    constexpr const char* const _type_name_PerceptionFrame = "PerceptionFrame";

    static PyObject* _new_PerceptionFrame(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_PerceptionFrame);
        return nullptr;
    }

    static void _dealloc_PerceptionFrame(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* PerceptionFrame_get_RelativeTime(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrame* self, void* /*unused*/) noexcept
    {
        try
        {
            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_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            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
        {
            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
        {
            return py::convert(self->obj.Properties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_PerceptionFrame },
        { Py_tp_dealloc, _dealloc_PerceptionFrame },
        { Py_tp_methods, _methods_PerceptionFrame },
        { Py_tp_getset, _getset_PerceptionFrame },
        { },
    };

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

    // ----- PerceptionFrameProviderInfo class --------------------
    constexpr const char* const _type_name_PerceptionFrameProviderInfo = "PerceptionFrameProviderInfo";

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

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* PerceptionFrameProviderInfo_get_Id(py::wrapper::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            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_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            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
        {
            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_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            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
        {
            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_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            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
        {
            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_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            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
        {
            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_TypeError, "property delete not supported");
            return -1;
        }

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

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

    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[] = {
        { "_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, _new_PerceptionFrameProviderInfo },
        { Py_tp_dealloc, _dealloc_PerceptionFrameProviderInfo },
        { Py_tp_methods, _methods_PerceptionFrameProviderInfo },
        { Py_tp_getset, _getset_PerceptionFrameProviderInfo },
        { },
    };

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

    // ----- PerceptionFrameProviderManagerService class --------------------
    constexpr const char* const _type_name_PerceptionFrameProviderManagerService = "PerceptionFrameProviderManagerService";

    static PyObject* _new_PerceptionFrameProviderManagerService(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_PerceptionFrameProviderManagerService);
        return nullptr;
    }

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

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                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[] = {
        { "publish_frame_for_provider", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_PublishFrameForProvider), METH_VARARGS | METH_STATIC, nullptr },
        { "register_control_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterControlGroup), METH_VARARGS | METH_STATIC, nullptr },
        { "register_correlation_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterCorrelationGroup), METH_VARARGS | METH_STATIC, nullptr },
        { "register_face_authentication_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterFaceAuthenticationGroup), METH_VARARGS | METH_STATIC, nullptr },
        { "register_frame_provider_info", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_RegisterFrameProviderInfo), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister_control_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterControlGroup), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister_correlation_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterCorrelationGroup), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister_face_authentication_group", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterFaceAuthenticationGroup), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister_frame_provider_info", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UnregisterFrameProviderInfo), METH_VARARGS | METH_STATIC, nullptr },
        { "update_availability_for_provider", reinterpret_cast<PyCFunction>(PerceptionFrameProviderManagerService_UpdateAvailabilityForProvider), METH_VARARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PerceptionFrameProviderManagerService[] = {
        { }
    };

    static PyType_Slot _type_slots_PerceptionFrameProviderManagerService[] = 
    {
        { Py_tp_new, _new_PerceptionFrameProviderManagerService },
        { Py_tp_methods, _methods_PerceptionFrameProviderManagerService },
        { Py_tp_getset, _getset_PerceptionFrameProviderManagerService },
        { },
    };

    static PyType_Spec _type_spec_PerceptionFrameProviderManagerService =
    {
        "_winsdk_Windows_Devices_Perception_Provider.PerceptionFrameProviderManagerService",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PerceptionFrameProviderManagerService
    };

    // ----- PerceptionPropertyChangeRequest class --------------------
    constexpr const char* const _type_name_PerceptionPropertyChangeRequest = "PerceptionPropertyChangeRequest";

    static PyObject* _new_PerceptionPropertyChangeRequest(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_PerceptionPropertyChangeRequest);
        return nullptr;
    }

    static void _dealloc_PerceptionPropertyChangeRequest(py::wrapper::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

        if (arg_count == 0)
        {
            try
            {
                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
        {
            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_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            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
        {
            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
        {
            return py::convert(self->obj.Value());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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 },
        { "_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, _new_PerceptionPropertyChangeRequest },
        { Py_tp_dealloc, _dealloc_PerceptionPropertyChangeRequest },
        { Py_tp_methods, _methods_PerceptionPropertyChangeRequest },
        { Py_tp_getset, _getset_PerceptionPropertyChangeRequest },
        { },
    };

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

    // ----- PerceptionVideoFrameAllocator class --------------------
    constexpr const char* const _type_name_PerceptionVideoFrameAllocator = "PerceptionVideoFrameAllocator";

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

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

        if (arg_count == 0)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                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* _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) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

    static PyObject* _exit_PerceptionVideoFrameAllocator(py::wrapper::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator* self) 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 },
        { "_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, _new_PerceptionVideoFrameAllocator },
        { Py_tp_dealloc, _dealloc_PerceptionVideoFrameAllocator },
        { Py_tp_methods, _methods_PerceptionVideoFrameAllocator },
        { Py_tp_getset, _getset_PerceptionVideoFrameAllocator },
        { },
    };

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

    // ----- IPerceptionFrameProvider interface --------------------
    constexpr const char* const _type_name_IPerceptionFrameProvider = "IPerceptionFrameProvider";

    static PyObject* _new_IPerceptionFrameProvider(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */)
    {
        py::set_invalid_activation_error(_type_name_IPerceptionFrameProvider);
        return nullptr;
    }

    static void _dealloc_IPerceptionFrameProvider(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProvider* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

        if (arg_count == 0)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                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
        {
            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
        {
            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
        {
            return py::convert(self->obj.Properties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

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

    static PyMethodDef _methods_IPerceptionFrameProvider[] = {
        { "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 },
        { "close", reinterpret_cast<PyCFunction>(IPerceptionFrameProvider_Close), METH_VARARGS, 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, _new_IPerceptionFrameProvider },
        { Py_tp_dealloc, _dealloc_IPerceptionFrameProvider },
        { Py_tp_methods, _methods_IPerceptionFrameProvider },
        { Py_tp_getset, _getset_IPerceptionFrameProvider },
        { },
    };

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

    // ----- IPerceptionFrameProviderManager interface --------------------
    constexpr const char* const _type_name_IPerceptionFrameProviderManager = "IPerceptionFrameProviderManager";

    static PyObject* _new_IPerceptionFrameProviderManager(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */)
    {
        py::set_invalid_activation_error(_type_name_IPerceptionFrameProviderManager);
        return nullptr;
    }

    static void _dealloc_IPerceptionFrameProviderManager(py::wrapper::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

        if (arg_count == 0)
        {
            try
            {
                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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                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* _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) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

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

    static PyMethodDef _methods_IPerceptionFrameProviderManager[] = {
        { "get_frame_provider", reinterpret_cast<PyCFunction>(IPerceptionFrameProviderManager_GetFrameProvider), METH_VARARGS, nullptr },
        { "close", reinterpret_cast<PyCFunction>(IPerceptionFrameProviderManager_Close), METH_VARARGS, 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, _new_IPerceptionFrameProviderManager },
        { Py_tp_dealloc, _dealloc_IPerceptionFrameProviderManager },
        { Py_tp_methods, _methods_IPerceptionFrameProviderManager },
        { Py_tp_getset, _getset_IPerceptionFrameProviderManager },
        { },
    };

    static PyType_Spec _type_spec_IPerceptionFrameProviderManager =
    {
        "_winsdk_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 --------------------
    static int module_exec(PyObject* module) noexcept
    {
        try
        {
            py::pyobj_handle bases { PyTuple_Pack(1, py::winrt_type<py::Object>::python_type) };

            py::winrt_type<winrt::Windows::Devices::Perception::Provider::KnownPerceptionFrameKind>::python_type = py::register_python_type(module, _type_name_KnownPerceptionFrameKind, &_type_spec_KnownPerceptionFrameKind, nullptr);
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionControlGroup>::python_type = py::register_python_type(module, _type_name_PerceptionControlGroup, &_type_spec_PerceptionControlGroup, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelation>::python_type = py::register_python_type(module, _type_name_PerceptionCorrelation, &_type_spec_PerceptionCorrelation, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionCorrelationGroup>::python_type = py::register_python_type(module, _type_name_PerceptionCorrelationGroup, &_type_spec_PerceptionCorrelationGroup, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFaceAuthenticationGroup>::python_type = py::register_python_type(module, _type_name_PerceptionFaceAuthenticationGroup, &_type_spec_PerceptionFaceAuthenticationGroup, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrame>::python_type = py::register_python_type(module, _type_name_PerceptionFrame, &_type_spec_PerceptionFrame, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderInfo>::python_type = py::register_python_type(module, _type_name_PerceptionFrameProviderInfo, &_type_spec_PerceptionFrameProviderInfo, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionFrameProviderManagerService>::python_type = py::register_python_type(module, _type_name_PerceptionFrameProviderManagerService, &_type_spec_PerceptionFrameProviderManagerService, nullptr);
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionPropertyChangeRequest>::python_type = py::register_python_type(module, _type_name_PerceptionPropertyChangeRequest, &_type_spec_PerceptionPropertyChangeRequest, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::PerceptionVideoFrameAllocator>::python_type = py::register_python_type(module, _type_name_PerceptionVideoFrameAllocator, &_type_spec_PerceptionVideoFrameAllocator, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProvider>::python_type = py::register_python_type(module, _type_name_IPerceptionFrameProvider, &_type_spec_IPerceptionFrameProvider, bases.get());
            py::winrt_type<winrt::Windows::Devices::Perception::Provider::IPerceptionFrameProviderManager>::python_type = py::register_python_type(module, _type_name_IPerceptionFrameProviderManager, &_type_spec_IPerceptionFrameProviderManager, bases.get());

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyModuleDef_Slot module_slots[] = {{Py_mod_exec, module_exec}, {}};

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

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

PyMODINIT_FUNC
PyInit__winsdk_Windows_Devices_Perception_Provider (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Devices::Perception::Provider::module_def);
}
