// 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.HumanInterfaceDevice.h"

PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidBooleanControl>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidCollection>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidDevice>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidFeatureReport>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidInputReport>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidInputReportReceivedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidNumericControl>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidOutputReport>::python_type;

namespace py::cpp::Windows::Devices::HumanInterfaceDevice
{
    // ----- HidBooleanControl class --------------------
    constexpr const char* const _type_name_HidBooleanControl = "HidBooleanControl";

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

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

    static PyObject* HidBooleanControl_get_IsActive(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsActive());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HidBooleanControl_put_IsActive(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControl* 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.IsActive(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HidBooleanControl_get_ControlDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ControlDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControl_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControl_get_UsageId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsageId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControl_get_UsagePage(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsagePage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidBooleanControl(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::HumanInterfaceDevice::HidBooleanControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidBooleanControl[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_HidBooleanControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidBooleanControl[] = {
        { "is_active", reinterpret_cast<getter>(HidBooleanControl_get_IsActive), reinterpret_cast<setter>(HidBooleanControl_put_IsActive), nullptr, nullptr },
        { "control_description", reinterpret_cast<getter>(HidBooleanControl_get_ControlDescription), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HidBooleanControl_get_Id), nullptr, nullptr, nullptr },
        { "usage_id", reinterpret_cast<getter>(HidBooleanControl_get_UsageId), nullptr, nullptr, nullptr },
        { "usage_page", reinterpret_cast<getter>(HidBooleanControl_get_UsagePage), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidBooleanControl[] = 
    {
        { Py_tp_new, _new_HidBooleanControl },
        { Py_tp_dealloc, _dealloc_HidBooleanControl },
        { Py_tp_methods, _methods_HidBooleanControl },
        { Py_tp_getset, _getset_HidBooleanControl },
        { },
    };

    static PyType_Spec _type_spec_HidBooleanControl =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidBooleanControl",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidBooleanControl
    };

    // ----- HidBooleanControlDescription class --------------------
    constexpr const char* const _type_name_HidBooleanControlDescription = "HidBooleanControlDescription";

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

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

    static PyObject* HidBooleanControlDescription_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControlDescription_get_ParentCollections(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentCollections());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControlDescription_get_ReportId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ReportId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControlDescription_get_ReportType(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ReportType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControlDescription_get_UsageId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsageId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControlDescription_get_UsagePage(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsagePage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidBooleanControlDescription_get_IsAbsolute(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsAbsolute());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidBooleanControlDescription(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::HumanInterfaceDevice::HidBooleanControlDescription>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidBooleanControlDescription[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_HidBooleanControlDescription), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidBooleanControlDescription[] = {
        { "id", reinterpret_cast<getter>(HidBooleanControlDescription_get_Id), nullptr, nullptr, nullptr },
        { "parent_collections", reinterpret_cast<getter>(HidBooleanControlDescription_get_ParentCollections), nullptr, nullptr, nullptr },
        { "report_id", reinterpret_cast<getter>(HidBooleanControlDescription_get_ReportId), nullptr, nullptr, nullptr },
        { "report_type", reinterpret_cast<getter>(HidBooleanControlDescription_get_ReportType), nullptr, nullptr, nullptr },
        { "usage_id", reinterpret_cast<getter>(HidBooleanControlDescription_get_UsageId), nullptr, nullptr, nullptr },
        { "usage_page", reinterpret_cast<getter>(HidBooleanControlDescription_get_UsagePage), nullptr, nullptr, nullptr },
        { "is_absolute", reinterpret_cast<getter>(HidBooleanControlDescription_get_IsAbsolute), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidBooleanControlDescription[] = 
    {
        { Py_tp_new, _new_HidBooleanControlDescription },
        { Py_tp_dealloc, _dealloc_HidBooleanControlDescription },
        { Py_tp_methods, _methods_HidBooleanControlDescription },
        { Py_tp_getset, _getset_HidBooleanControlDescription },
        { },
    };

    static PyType_Spec _type_spec_HidBooleanControlDescription =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidBooleanControlDescription",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidBooleanControlDescription
    };

    // ----- HidCollection class --------------------
    constexpr const char* const _type_name_HidCollection = "HidCollection";

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

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

    static PyObject* HidCollection_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidCollection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidCollection_get_Type(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidCollection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Type());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidCollection_get_UsageId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidCollection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsageId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidCollection_get_UsagePage(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidCollection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsagePage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidCollection(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::HumanInterfaceDevice::HidCollection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidCollection[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_HidCollection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidCollection[] = {
        { "id", reinterpret_cast<getter>(HidCollection_get_Id), nullptr, nullptr, nullptr },
        { "type", reinterpret_cast<getter>(HidCollection_get_Type), nullptr, nullptr, nullptr },
        { "usage_id", reinterpret_cast<getter>(HidCollection_get_UsageId), nullptr, nullptr, nullptr },
        { "usage_page", reinterpret_cast<getter>(HidCollection_get_UsagePage), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidCollection[] = 
    {
        { Py_tp_new, _new_HidCollection },
        { Py_tp_dealloc, _dealloc_HidCollection },
        { Py_tp_methods, _methods_HidCollection },
        { Py_tp_getset, _getset_HidCollection },
        { },
    };

    static PyType_Spec _type_spec_HidCollection =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidCollection",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidCollection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidCollection
    };

    // ----- HidDevice class --------------------
    constexpr const char* const _type_name_HidDevice = "HidDevice";

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

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

    static PyObject* HidDevice_Close(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* 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* HidDevice_CreateFeatureReport(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.CreateFeatureReport());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);

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

    static PyObject* HidDevice_CreateOutputReport(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.CreateOutputReport());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);

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

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

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::FileAccessMode>(args, 1);

                return py::convert(winrt::Windows::Devices::HumanInterfaceDevice::HidDevice::FromIdAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HidDevice_GetBooleanControlDescriptions(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::HumanInterfaceDevice::HidReportType>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);
                auto param2 = py::convert_to<uint16_t>(args, 2);

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

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

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);

                return py::convert(winrt::Windows::Devices::HumanInterfaceDevice::HidDevice::GetDeviceSelector(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 4)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);
                auto param2 = py::convert_to<uint16_t>(args, 2);
                auto param3 = py::convert_to<uint16_t>(args, 3);

                return py::convert(winrt::Windows::Devices::HumanInterfaceDevice::HidDevice::GetDeviceSelector(param0, param1, param2, param3));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HidDevice_GetFeatureReportAsync(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetFeatureReportAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);

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

    static PyObject* HidDevice_GetInputReportAsync(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetInputReportAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);

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

    static PyObject* HidDevice_GetNumericControlDescriptions(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::HumanInterfaceDevice::HidReportType>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);
                auto param2 = py::convert_to<uint16_t>(args, 2);

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

    static PyObject* HidDevice_SendFeatureReportAsync(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* 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::HumanInterfaceDevice::HidFeatureReport>(args, 0);

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

    static PyObject* HidDevice_SendOutputReportAsync(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* 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::HumanInterfaceDevice::HidOutputReport>(args, 0);

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

    static PyObject* HidDevice_get_ProductId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidDevice_get_UsageId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsageId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidDevice_get_UsagePage(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsagePage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidDevice_get_VendorId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.VendorId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidDevice_get_Version(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Version());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidDevice_add_InputReportReceived(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::HumanInterfaceDevice::HidDevice, winrt::Windows::Devices::HumanInterfaceDevice::HidInputReportReceivedEventArgs>>(arg);

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

    static PyObject* HidDevice_remove_InputReportReceived(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.InputReportReceived(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidDevice(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::HumanInterfaceDevice::HidDevice>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_HidDevice(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

    static PyObject* _exit_HidDevice(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice* self) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidDevice[] = {
        { "close", reinterpret_cast<PyCFunction>(HidDevice_Close), METH_VARARGS, nullptr },
        { "create_feature_report", reinterpret_cast<PyCFunction>(HidDevice_CreateFeatureReport), METH_VARARGS, nullptr },
        { "create_output_report", reinterpret_cast<PyCFunction>(HidDevice_CreateOutputReport), METH_VARARGS, nullptr },
        { "from_id_async", reinterpret_cast<PyCFunction>(HidDevice_FromIdAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_boolean_control_descriptions", reinterpret_cast<PyCFunction>(HidDevice_GetBooleanControlDescriptions), METH_VARARGS, nullptr },
        { "get_device_selector", reinterpret_cast<PyCFunction>(HidDevice_GetDeviceSelector), METH_VARARGS | METH_STATIC, nullptr },
        { "get_feature_report_async", reinterpret_cast<PyCFunction>(HidDevice_GetFeatureReportAsync), METH_VARARGS, nullptr },
        { "get_input_report_async", reinterpret_cast<PyCFunction>(HidDevice_GetInputReportAsync), METH_VARARGS, nullptr },
        { "get_numeric_control_descriptions", reinterpret_cast<PyCFunction>(HidDevice_GetNumericControlDescriptions), METH_VARARGS, nullptr },
        { "send_feature_report_async", reinterpret_cast<PyCFunction>(HidDevice_SendFeatureReportAsync), METH_VARARGS, nullptr },
        { "send_output_report_async", reinterpret_cast<PyCFunction>(HidDevice_SendOutputReportAsync), METH_VARARGS, nullptr },
        { "add_input_report_received", reinterpret_cast<PyCFunction>(HidDevice_add_InputReportReceived), METH_O, nullptr },
        { "remove_input_report_received", reinterpret_cast<PyCFunction>(HidDevice_remove_InputReportReceived), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HidDevice), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_HidDevice), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_HidDevice), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidDevice[] = {
        { "product_id", reinterpret_cast<getter>(HidDevice_get_ProductId), nullptr, nullptr, nullptr },
        { "usage_id", reinterpret_cast<getter>(HidDevice_get_UsageId), nullptr, nullptr, nullptr },
        { "usage_page", reinterpret_cast<getter>(HidDevice_get_UsagePage), nullptr, nullptr, nullptr },
        { "vendor_id", reinterpret_cast<getter>(HidDevice_get_VendorId), nullptr, nullptr, nullptr },
        { "version", reinterpret_cast<getter>(HidDevice_get_Version), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidDevice[] = 
    {
        { Py_tp_new, _new_HidDevice },
        { Py_tp_dealloc, _dealloc_HidDevice },
        { Py_tp_methods, _methods_HidDevice },
        { Py_tp_getset, _getset_HidDevice },
        { },
    };

    static PyType_Spec _type_spec_HidDevice =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidDevice",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidDevice),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidDevice
    };

    // ----- HidFeatureReport class --------------------
    constexpr const char* const _type_name_HidFeatureReport = "HidFeatureReport";

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

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

    static PyObject* HidFeatureReport_GetBooleanControl(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);

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

    static PyObject* HidFeatureReport_GetBooleanControlByDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport* 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::HumanInterfaceDevice::HidBooleanControlDescription>(args, 0);

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

    static PyObject* HidFeatureReport_GetNumericControl(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);

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

    static PyObject* HidFeatureReport_GetNumericControlByDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport* 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::HumanInterfaceDevice::HidNumericControlDescription>(args, 0);

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

    static PyObject* HidFeatureReport_get_Data(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HidFeatureReport_put_Data(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport* 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::Storage::Streams::IBuffer>(arg);

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

    static PyObject* HidFeatureReport_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidFeatureReport(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::HumanInterfaceDevice::HidFeatureReport>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidFeatureReport[] = {
        { "get_boolean_control", reinterpret_cast<PyCFunction>(HidFeatureReport_GetBooleanControl), METH_VARARGS, nullptr },
        { "get_boolean_control_by_description", reinterpret_cast<PyCFunction>(HidFeatureReport_GetBooleanControlByDescription), METH_VARARGS, nullptr },
        { "get_numeric_control", reinterpret_cast<PyCFunction>(HidFeatureReport_GetNumericControl), METH_VARARGS, nullptr },
        { "get_numeric_control_by_description", reinterpret_cast<PyCFunction>(HidFeatureReport_GetNumericControlByDescription), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HidFeatureReport), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidFeatureReport[] = {
        { "data", reinterpret_cast<getter>(HidFeatureReport_get_Data), reinterpret_cast<setter>(HidFeatureReport_put_Data), nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HidFeatureReport_get_Id), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidFeatureReport[] = 
    {
        { Py_tp_new, _new_HidFeatureReport },
        { Py_tp_dealloc, _dealloc_HidFeatureReport },
        { Py_tp_methods, _methods_HidFeatureReport },
        { Py_tp_getset, _getset_HidFeatureReport },
        { },
    };

    static PyType_Spec _type_spec_HidFeatureReport =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidFeatureReport",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidFeatureReport),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidFeatureReport
    };

    // ----- HidInputReport class --------------------
    constexpr const char* const _type_name_HidInputReport = "HidInputReport";

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

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

    static PyObject* HidInputReport_GetBooleanControl(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);

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

    static PyObject* HidInputReport_GetBooleanControlByDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* 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::HumanInterfaceDevice::HidBooleanControlDescription>(args, 0);

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

    static PyObject* HidInputReport_GetNumericControl(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);

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

    static PyObject* HidInputReport_GetNumericControlByDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* 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::HumanInterfaceDevice::HidNumericControlDescription>(args, 0);

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

    static PyObject* HidInputReport_get_ActivatedBooleanControls(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ActivatedBooleanControls());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidInputReport_get_Data(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidInputReport_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidInputReport_get_TransitionedBooleanControls(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.TransitionedBooleanControls());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidInputReport(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::HumanInterfaceDevice::HidInputReport>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidInputReport[] = {
        { "get_boolean_control", reinterpret_cast<PyCFunction>(HidInputReport_GetBooleanControl), METH_VARARGS, nullptr },
        { "get_boolean_control_by_description", reinterpret_cast<PyCFunction>(HidInputReport_GetBooleanControlByDescription), METH_VARARGS, nullptr },
        { "get_numeric_control", reinterpret_cast<PyCFunction>(HidInputReport_GetNumericControl), METH_VARARGS, nullptr },
        { "get_numeric_control_by_description", reinterpret_cast<PyCFunction>(HidInputReport_GetNumericControlByDescription), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HidInputReport), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidInputReport[] = {
        { "activated_boolean_controls", reinterpret_cast<getter>(HidInputReport_get_ActivatedBooleanControls), nullptr, nullptr, nullptr },
        { "data", reinterpret_cast<getter>(HidInputReport_get_Data), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HidInputReport_get_Id), nullptr, nullptr, nullptr },
        { "transitioned_boolean_controls", reinterpret_cast<getter>(HidInputReport_get_TransitionedBooleanControls), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidInputReport[] = 
    {
        { Py_tp_new, _new_HidInputReport },
        { Py_tp_dealloc, _dealloc_HidInputReport },
        { Py_tp_methods, _methods_HidInputReport },
        { Py_tp_getset, _getset_HidInputReport },
        { },
    };

    static PyType_Spec _type_spec_HidInputReport =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidInputReport",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReport),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidInputReport
    };

    // ----- HidInputReportReceivedEventArgs class --------------------
    constexpr const char* const _type_name_HidInputReportReceivedEventArgs = "HidInputReportReceivedEventArgs";

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

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

    static PyObject* HidInputReportReceivedEventArgs_get_Report(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReportReceivedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Report());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidInputReportReceivedEventArgs(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::HumanInterfaceDevice::HidInputReportReceivedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidInputReportReceivedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_HidInputReportReceivedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidInputReportReceivedEventArgs[] = {
        { "report", reinterpret_cast<getter>(HidInputReportReceivedEventArgs_get_Report), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidInputReportReceivedEventArgs[] = 
    {
        { Py_tp_new, _new_HidInputReportReceivedEventArgs },
        { Py_tp_dealloc, _dealloc_HidInputReportReceivedEventArgs },
        { Py_tp_methods, _methods_HidInputReportReceivedEventArgs },
        { Py_tp_getset, _getset_HidInputReportReceivedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_HidInputReportReceivedEventArgs =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidInputReportReceivedEventArgs",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidInputReportReceivedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidInputReportReceivedEventArgs
    };

    // ----- HidNumericControl class --------------------
    constexpr const char* const _type_name_HidNumericControl = "HidNumericControl";

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

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

    static PyObject* HidNumericControl_get_Value(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Value());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HidNumericControl_put_Value(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* 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<int64_t>(arg);

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

    static PyObject* HidNumericControl_get_ScaledValue(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ScaledValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HidNumericControl_put_ScaledValue(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* 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<int64_t>(arg);

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

    static PyObject* HidNumericControl_get_ControlDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ControlDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControl_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControl_get_IsGrouped(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsGrouped());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControl_get_UsageId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsageId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControl_get_UsagePage(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsagePage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidNumericControl(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::HumanInterfaceDevice::HidNumericControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidNumericControl[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_HidNumericControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidNumericControl[] = {
        { "value", reinterpret_cast<getter>(HidNumericControl_get_Value), reinterpret_cast<setter>(HidNumericControl_put_Value), nullptr, nullptr },
        { "scaled_value", reinterpret_cast<getter>(HidNumericControl_get_ScaledValue), reinterpret_cast<setter>(HidNumericControl_put_ScaledValue), nullptr, nullptr },
        { "control_description", reinterpret_cast<getter>(HidNumericControl_get_ControlDescription), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HidNumericControl_get_Id), nullptr, nullptr, nullptr },
        { "is_grouped", reinterpret_cast<getter>(HidNumericControl_get_IsGrouped), nullptr, nullptr, nullptr },
        { "usage_id", reinterpret_cast<getter>(HidNumericControl_get_UsageId), nullptr, nullptr, nullptr },
        { "usage_page", reinterpret_cast<getter>(HidNumericControl_get_UsagePage), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidNumericControl[] = 
    {
        { Py_tp_new, _new_HidNumericControl },
        { Py_tp_dealloc, _dealloc_HidNumericControl },
        { Py_tp_methods, _methods_HidNumericControl },
        { Py_tp_getset, _getset_HidNumericControl },
        { },
    };

    static PyType_Spec _type_spec_HidNumericControl =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidNumericControl",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidNumericControl
    };

    // ----- HidNumericControlDescription class --------------------
    constexpr const char* const _type_name_HidNumericControlDescription = "HidNumericControlDescription";

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

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

    static PyObject* HidNumericControlDescription_get_HasNull(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.HasNull());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_IsAbsolute(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsAbsolute());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_LogicalMaximum(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LogicalMaximum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_LogicalMinimum(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LogicalMinimum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_ParentCollections(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentCollections());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_PhysicalMaximum(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PhysicalMaximum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_PhysicalMinimum(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PhysicalMinimum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_ReportCount(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ReportCount());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_ReportId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ReportId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_ReportSize(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ReportSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_ReportType(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ReportType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_Unit(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Unit());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_UnitExponent(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UnitExponent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_UsageId(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsageId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HidNumericControlDescription_get_UsagePage(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.UsagePage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidNumericControlDescription(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::HumanInterfaceDevice::HidNumericControlDescription>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidNumericControlDescription[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_HidNumericControlDescription), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidNumericControlDescription[] = {
        { "has_null", reinterpret_cast<getter>(HidNumericControlDescription_get_HasNull), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HidNumericControlDescription_get_Id), nullptr, nullptr, nullptr },
        { "is_absolute", reinterpret_cast<getter>(HidNumericControlDescription_get_IsAbsolute), nullptr, nullptr, nullptr },
        { "logical_maximum", reinterpret_cast<getter>(HidNumericControlDescription_get_LogicalMaximum), nullptr, nullptr, nullptr },
        { "logical_minimum", reinterpret_cast<getter>(HidNumericControlDescription_get_LogicalMinimum), nullptr, nullptr, nullptr },
        { "parent_collections", reinterpret_cast<getter>(HidNumericControlDescription_get_ParentCollections), nullptr, nullptr, nullptr },
        { "physical_maximum", reinterpret_cast<getter>(HidNumericControlDescription_get_PhysicalMaximum), nullptr, nullptr, nullptr },
        { "physical_minimum", reinterpret_cast<getter>(HidNumericControlDescription_get_PhysicalMinimum), nullptr, nullptr, nullptr },
        { "report_count", reinterpret_cast<getter>(HidNumericControlDescription_get_ReportCount), nullptr, nullptr, nullptr },
        { "report_id", reinterpret_cast<getter>(HidNumericControlDescription_get_ReportId), nullptr, nullptr, nullptr },
        { "report_size", reinterpret_cast<getter>(HidNumericControlDescription_get_ReportSize), nullptr, nullptr, nullptr },
        { "report_type", reinterpret_cast<getter>(HidNumericControlDescription_get_ReportType), nullptr, nullptr, nullptr },
        { "unit", reinterpret_cast<getter>(HidNumericControlDescription_get_Unit), nullptr, nullptr, nullptr },
        { "unit_exponent", reinterpret_cast<getter>(HidNumericControlDescription_get_UnitExponent), nullptr, nullptr, nullptr },
        { "usage_id", reinterpret_cast<getter>(HidNumericControlDescription_get_UsageId), nullptr, nullptr, nullptr },
        { "usage_page", reinterpret_cast<getter>(HidNumericControlDescription_get_UsagePage), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidNumericControlDescription[] = 
    {
        { Py_tp_new, _new_HidNumericControlDescription },
        { Py_tp_dealloc, _dealloc_HidNumericControlDescription },
        { Py_tp_methods, _methods_HidNumericControlDescription },
        { Py_tp_getset, _getset_HidNumericControlDescription },
        { },
    };

    static PyType_Spec _type_spec_HidNumericControlDescription =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidNumericControlDescription",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidNumericControlDescription
    };

    // ----- HidOutputReport class --------------------
    constexpr const char* const _type_name_HidOutputReport = "HidOutputReport";

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

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

    static PyObject* HidOutputReport_GetBooleanControl(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);

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

    static PyObject* HidOutputReport_GetBooleanControlByDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport* 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::HumanInterfaceDevice::HidBooleanControlDescription>(args, 0);

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

    static PyObject* HidOutputReport_GetNumericControl(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint16_t>(args, 0);
                auto param1 = py::convert_to<uint16_t>(args, 1);

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

    static PyObject* HidOutputReport_GetNumericControlByDescription(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport* 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::HumanInterfaceDevice::HidNumericControlDescription>(args, 0);

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

    static PyObject* HidOutputReport_get_Data(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HidOutputReport_put_Data(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport* 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::Storage::Streams::IBuffer>(arg);

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

    static PyObject* HidOutputReport_get_Id(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HidOutputReport(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::HumanInterfaceDevice::HidOutputReport>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HidOutputReport[] = {
        { "get_boolean_control", reinterpret_cast<PyCFunction>(HidOutputReport_GetBooleanControl), METH_VARARGS, nullptr },
        { "get_boolean_control_by_description", reinterpret_cast<PyCFunction>(HidOutputReport_GetBooleanControlByDescription), METH_VARARGS, nullptr },
        { "get_numeric_control", reinterpret_cast<PyCFunction>(HidOutputReport_GetNumericControl), METH_VARARGS, nullptr },
        { "get_numeric_control_by_description", reinterpret_cast<PyCFunction>(HidOutputReport_GetNumericControlByDescription), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HidOutputReport), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HidOutputReport[] = {
        { "data", reinterpret_cast<getter>(HidOutputReport_get_Data), reinterpret_cast<setter>(HidOutputReport_put_Data), nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HidOutputReport_get_Id), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HidOutputReport[] = 
    {
        { Py_tp_new, _new_HidOutputReport },
        { Py_tp_dealloc, _dealloc_HidOutputReport },
        { Py_tp_methods, _methods_HidOutputReport },
        { Py_tp_getset, _getset_HidOutputReport },
        { },
    };

    static PyType_Spec _type_spec_HidOutputReport =
    {
        "_winsdk_Windows_Devices_HumanInterfaceDevice.HidOutputReport",
        sizeof(py::wrapper::Windows::Devices::HumanInterfaceDevice::HidOutputReport),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HidOutputReport
    };

    // ----- Windows.Devices.HumanInterfaceDevice 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::HumanInterfaceDevice::HidBooleanControl>::python_type = py::register_python_type(module, _type_name_HidBooleanControl, &_type_spec_HidBooleanControl, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidBooleanControlDescription>::python_type = py::register_python_type(module, _type_name_HidBooleanControlDescription, &_type_spec_HidBooleanControlDescription, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidCollection>::python_type = py::register_python_type(module, _type_name_HidCollection, &_type_spec_HidCollection, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidDevice>::python_type = py::register_python_type(module, _type_name_HidDevice, &_type_spec_HidDevice, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidFeatureReport>::python_type = py::register_python_type(module, _type_name_HidFeatureReport, &_type_spec_HidFeatureReport, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidInputReport>::python_type = py::register_python_type(module, _type_name_HidInputReport, &_type_spec_HidInputReport, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidInputReportReceivedEventArgs>::python_type = py::register_python_type(module, _type_name_HidInputReportReceivedEventArgs, &_type_spec_HidInputReportReceivedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidNumericControl>::python_type = py::register_python_type(module, _type_name_HidNumericControl, &_type_spec_HidNumericControl, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidNumericControlDescription>::python_type = py::register_python_type(module, _type_name_HidNumericControlDescription, &_type_spec_HidNumericControlDescription, bases.get());
            py::winrt_type<winrt::Windows::Devices::HumanInterfaceDevice::HidOutputReport>::python_type = py::register_python_type(module, _type_name_HidOutputReport, &_type_spec_HidOutputReport, 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.HumanInterfaceDevice");

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

PyMODINIT_FUNC
PyInit__winsdk_Windows_Devices_HumanInterfaceDevice (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Devices::HumanInterfaceDevice::module_def);
}
