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

#include "pybase.h"
#include "py.Windows.Security.Authentication.Identity.Provider.h"


namespace py::cpp::Windows::Security::Authentication::Identity::Provider
{
    struct module_state
    {
        PyObject* type_SecondaryAuthenticationFactorAuthenticationMessage;
        PyObject* type_SecondaryAuthenticationFactorAuthenticationScenario;
        PyObject* type_SecondaryAuthenticationFactorAuthenticationStage;
        PyObject* type_SecondaryAuthenticationFactorAuthenticationStatus;
        PyObject* type_SecondaryAuthenticationFactorDeviceCapabilities;
        PyObject* type_SecondaryAuthenticationFactorDeviceFindScope;
        PyObject* type_SecondaryAuthenticationFactorDevicePresence;
        PyObject* type_SecondaryAuthenticationFactorDevicePresenceMonitoringMode;
        PyObject* type_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus;
        PyObject* type_SecondaryAuthenticationFactorFinishAuthenticationStatus;
        PyObject* type_SecondaryAuthenticationFactorRegistrationStatus;
        PyTypeObject* type_SecondaryAuthenticationFactorAuthentication;
        PyTypeObject* type_SecondaryAuthenticationFactorAuthenticationResult;
        PyTypeObject* type_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs;
        PyTypeObject* type_SecondaryAuthenticationFactorAuthenticationStageInfo;
        PyTypeObject* type_SecondaryAuthenticationFactorInfo;
        PyTypeObject* type_SecondaryAuthenticationFactorRegistration;
        PyTypeObject* type_SecondaryAuthenticationFactorRegistrationResult;
    };

    static PyObject* register_SecondaryAuthenticationFactorAuthenticationMessage(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorAuthenticationMessage)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorAuthenticationMessage = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorAuthenticationMessage);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorAuthenticationScenario(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorAuthenticationScenario)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorAuthenticationScenario = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorAuthenticationScenario);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorAuthenticationStage(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorAuthenticationStage)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorAuthenticationStage = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorAuthenticationStage);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorAuthenticationStatus(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorAuthenticationStatus)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorAuthenticationStatus = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorAuthenticationStatus);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorDeviceCapabilities(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorDeviceCapabilities)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorDeviceCapabilities = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorDeviceCapabilities);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorDeviceFindScope(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorDeviceFindScope)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorDeviceFindScope = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorDeviceFindScope);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorDevicePresence(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorDevicePresence)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorDevicePresence = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorDevicePresence);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorDevicePresenceMonitoringMode(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringMode)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringMode = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringMode);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorFinishAuthenticationStatus(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorFinishAuthenticationStatus)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorFinishAuthenticationStatus = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorFinishAuthenticationStatus);


        Py_RETURN_NONE;
    }

    static PyObject* register_SecondaryAuthenticationFactorRegistrationStatus(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SecondaryAuthenticationFactorRegistrationStatus)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SecondaryAuthenticationFactorRegistrationStatus = type;
        Py_INCREF(state->type_SecondaryAuthenticationFactorRegistrationStatus);


        Py_RETURN_NONE;
    }

    // ----- SecondaryAuthenticationFactorAuthentication class --------------------
    static constexpr const char* const type_name_SecondaryAuthenticationFactorAuthentication = "SecondaryAuthenticationFactorAuthentication";

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

    static void _dealloc_SecondaryAuthenticationFactorAuthentication(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SecondaryAuthenticationFactorAuthentication_AbortAuthenticationAsync(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"AbortAuthenticationAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

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

    static PyObject* SecondaryAuthenticationFactorAuthentication_FinishAuthenticationAsync(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"FinishAuthenticationAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 1);

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

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"GetAuthenticationStageInfoAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication::GetAuthenticationStageInfoAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"ShowNotificationMessageAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationMessage>(args, 1);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication::ShowNotificationMessageAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"StartAuthenticationAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 1);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication::StartAuthenticationAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SecondaryAuthenticationFactorAuthentication_get_DeviceConfigurationData(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"DeviceConfigurationData"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorAuthentication_get_DeviceNonce(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"DeviceNonce"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorAuthentication_get_ServiceAuthenticationHmac(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"ServiceAuthenticationHmac"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorAuthentication_get_SessionNonce(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"SessionNonce"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorAuthentication_add_AuthenticationStageChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"AuthenticationStageChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>>(arg);

            return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication::AuthenticationStageChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SecondaryAuthenticationFactorAuthentication_remove_AuthenticationStageChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication", L"AuthenticationStageChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

            winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication::AuthenticationStageChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SecondaryAuthenticationFactorAuthentication(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SecondaryAuthenticationFactorAuthentication(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::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SecondaryAuthenticationFactorAuthentication[] = {
        { "abort_authentication_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorAuthentication_AbortAuthenticationAsync), METH_VARARGS, nullptr },
        { "finish_authentication_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorAuthentication_FinishAuthenticationAsync), METH_VARARGS, nullptr },
        { "get_authentication_stage_info_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorAuthentication_GetAuthenticationStageInfoAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "show_notification_message_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorAuthentication_ShowNotificationMessageAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "start_authentication_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorAuthentication_StartAuthenticationAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "add_authentication_stage_changed", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorAuthentication_add_AuthenticationStageChanged), METH_O | METH_STATIC, nullptr },
        { "remove_authentication_stage_changed", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorAuthentication_remove_AuthenticationStageChanged), METH_O | METH_STATIC, nullptr },
        { "_assign_array_", _assign_array_SecondaryAuthenticationFactorAuthentication, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorAuthentication), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorAuthentication[] = {
        { "device_configuration_data", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthentication_get_DeviceConfigurationData), nullptr, nullptr, nullptr },
        { "device_nonce", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthentication_get_DeviceNonce), nullptr, nullptr, nullptr },
        { "service_authentication_hmac", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthentication_get_ServiceAuthenticationHmac), nullptr, nullptr, nullptr },
        { "session_nonce", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthentication_get_SessionNonce), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorAuthentication[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SecondaryAuthenticationFactorAuthentication) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SecondaryAuthenticationFactorAuthentication) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SecondaryAuthenticationFactorAuthentication) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SecondaryAuthenticationFactorAuthentication) },
        { },
    };

    static PyType_Spec type_spec_SecondaryAuthenticationFactorAuthentication =
    {
        "_winsdk_Windows_Security_Authentication_Identity_Provider.SecondaryAuthenticationFactorAuthentication",
        sizeof(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SecondaryAuthenticationFactorAuthentication
    };

    // ----- SecondaryAuthenticationFactorAuthenticationResult class --------------------
    static constexpr const char* const type_name_SecondaryAuthenticationFactorAuthenticationResult = "SecondaryAuthenticationFactorAuthenticationResult";

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

    static void _dealloc_SecondaryAuthenticationFactorAuthenticationResult(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SecondaryAuthenticationFactorAuthenticationResult_get_Authentication(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationResult", L"Authentication"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorAuthenticationResult_get_Status(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationResult", L"Status"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_SecondaryAuthenticationFactorAuthenticationResult(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SecondaryAuthenticationFactorAuthenticationResult(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::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SecondaryAuthenticationFactorAuthenticationResult[] = {
        { "_assign_array_", _assign_array_SecondaryAuthenticationFactorAuthenticationResult, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorAuthenticationResult), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorAuthenticationResult[] = {
        { "authentication", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthenticationResult_get_Authentication), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthenticationResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorAuthenticationResult[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SecondaryAuthenticationFactorAuthenticationResult) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SecondaryAuthenticationFactorAuthenticationResult) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SecondaryAuthenticationFactorAuthenticationResult) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SecondaryAuthenticationFactorAuthenticationResult) },
        { },
    };

    static PyType_Spec type_spec_SecondaryAuthenticationFactorAuthenticationResult =
    {
        "_winsdk_Windows_Security_Authentication_Identity_Provider.SecondaryAuthenticationFactorAuthenticationResult",
        sizeof(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SecondaryAuthenticationFactorAuthenticationResult
    };

    // ----- SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs class --------------------
    static constexpr const char* const type_name_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs = "SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs";

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

    static void _dealloc_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs_get_StageInfo(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs", L"StageInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs(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::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs[] = {
        { "_assign_array_", _assign_array_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs[] = {
        { "stage_info", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs_get_StageInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs =
    {
        "_winsdk_Windows_Security_Authentication_Identity_Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs",
        sizeof(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs
    };

    // ----- SecondaryAuthenticationFactorAuthenticationStageInfo class --------------------
    static constexpr const char* const type_name_SecondaryAuthenticationFactorAuthenticationStageInfo = "SecondaryAuthenticationFactorAuthenticationStageInfo";

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

    static void _dealloc_SecondaryAuthenticationFactorAuthenticationStageInfo(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SecondaryAuthenticationFactorAuthenticationStageInfo_get_DeviceId(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo", L"DeviceId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorAuthenticationStageInfo_get_Scenario(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo", L"Scenario"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorAuthenticationStageInfo_get_Stage(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo", L"Stage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_SecondaryAuthenticationFactorAuthenticationStageInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SecondaryAuthenticationFactorAuthenticationStageInfo(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::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SecondaryAuthenticationFactorAuthenticationStageInfo[] = {
        { "_assign_array_", _assign_array_SecondaryAuthenticationFactorAuthenticationStageInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorAuthenticationStageInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorAuthenticationStageInfo[] = {
        { "device_id", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthenticationStageInfo_get_DeviceId), nullptr, nullptr, nullptr },
        { "scenario", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthenticationStageInfo_get_Scenario), nullptr, nullptr, nullptr },
        { "stage", reinterpret_cast<getter>(SecondaryAuthenticationFactorAuthenticationStageInfo_get_Stage), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorAuthenticationStageInfo[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SecondaryAuthenticationFactorAuthenticationStageInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SecondaryAuthenticationFactorAuthenticationStageInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SecondaryAuthenticationFactorAuthenticationStageInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SecondaryAuthenticationFactorAuthenticationStageInfo) },
        { },
    };

    static PyType_Spec type_spec_SecondaryAuthenticationFactorAuthenticationStageInfo =
    {
        "_winsdk_Windows_Security_Authentication_Identity_Provider.SecondaryAuthenticationFactorAuthenticationStageInfo",
        sizeof(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SecondaryAuthenticationFactorAuthenticationStageInfo
    };

    // ----- SecondaryAuthenticationFactorInfo class --------------------
    static constexpr const char* const type_name_SecondaryAuthenticationFactorInfo = "SecondaryAuthenticationFactorInfo";

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

    static void _dealloc_SecondaryAuthenticationFactorInfo(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SecondaryAuthenticationFactorInfo_UpdateDevicePresenceAsync(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo", L"UpdateDevicePresenceAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresence>(args, 0);

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

    static PyObject* SecondaryAuthenticationFactorInfo_get_DeviceConfigurationData(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo", L"DeviceConfigurationData"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorInfo_get_DeviceFriendlyName(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo", L"DeviceFriendlyName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorInfo_get_DeviceId(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo", L"DeviceId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorInfo_get_DeviceModelNumber(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo", L"DeviceModelNumber"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorInfo_get_IsAuthenticationSupported(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo", L"IsAuthenticationSupported"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorInfo_get_PresenceMonitoringMode(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo", L"PresenceMonitoringMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_SecondaryAuthenticationFactorInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SecondaryAuthenticationFactorInfo(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::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SecondaryAuthenticationFactorInfo[] = {
        { "update_device_presence_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorInfo_UpdateDevicePresenceAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_SecondaryAuthenticationFactorInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorInfo[] = {
        { "device_configuration_data", reinterpret_cast<getter>(SecondaryAuthenticationFactorInfo_get_DeviceConfigurationData), nullptr, nullptr, nullptr },
        { "device_friendly_name", reinterpret_cast<getter>(SecondaryAuthenticationFactorInfo_get_DeviceFriendlyName), nullptr, nullptr, nullptr },
        { "device_id", reinterpret_cast<getter>(SecondaryAuthenticationFactorInfo_get_DeviceId), nullptr, nullptr, nullptr },
        { "device_model_number", reinterpret_cast<getter>(SecondaryAuthenticationFactorInfo_get_DeviceModelNumber), nullptr, nullptr, nullptr },
        { "is_authentication_supported", reinterpret_cast<getter>(SecondaryAuthenticationFactorInfo_get_IsAuthenticationSupported), nullptr, nullptr, nullptr },
        { "presence_monitoring_mode", reinterpret_cast<getter>(SecondaryAuthenticationFactorInfo_get_PresenceMonitoringMode), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorInfo[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SecondaryAuthenticationFactorInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SecondaryAuthenticationFactorInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SecondaryAuthenticationFactorInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SecondaryAuthenticationFactorInfo) },
        { },
    };

    static PyType_Spec type_spec_SecondaryAuthenticationFactorInfo =
    {
        "_winsdk_Windows_Security_Authentication_Identity_Provider.SecondaryAuthenticationFactorInfo",
        sizeof(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SecondaryAuthenticationFactorInfo
    };

    // ----- SecondaryAuthenticationFactorRegistration class --------------------
    static constexpr const char* const type_name_SecondaryAuthenticationFactorRegistration = "SecondaryAuthenticationFactorRegistration";

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

    static void _dealloc_SecondaryAuthenticationFactorRegistration(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SecondaryAuthenticationFactorRegistration_AbortRegisteringDeviceAsync(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"AbortRegisteringDeviceAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

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

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"FindAllRegisteredDeviceInfoAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDeviceFindScope>(args, 0);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::FindAllRegisteredDeviceInfoAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SecondaryAuthenticationFactorRegistration_FinishRegisteringDeviceAsync(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"FinishRegisteringDeviceAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 0);

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

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"IsDevicePresenceMonitoringSupported", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::IsDevicePresenceMonitoringSupported());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"RegisterDevicePresenceMonitoringAsync", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresenceMonitoringMode>(args, 2);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::RegisterDevicePresenceMonitoringAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 6)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"RegisterDevicePresenceMonitoringAsync", 6))
            {
                py::set_arg_count_version_error(6);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresenceMonitoringMode>(args, 2);
                auto param3 = py::convert_to<winrt::hstring>(args, 3);
                auto param4 = py::convert_to<winrt::hstring>(args, 4);
                auto param5 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 5);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::RegisterDevicePresenceMonitoringAsync(param0, param1, param2, param3, param4, param5));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 6)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"RequestStartRegisteringDeviceAsync", 6))
            {
                py::set_arg_count_version_error(6);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDeviceCapabilities>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);
                auto param3 = py::convert_to<winrt::hstring>(args, 3);
                auto param4 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 4);
                auto param5 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 5);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::RequestStartRegisteringDeviceAsync(param0, param1, param2, param3, param4, param5));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"UnregisterDeviceAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::UnregisterDeviceAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"UnregisterDevicePresenceMonitoringAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::UnregisterDevicePresenceMonitoringAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration", L"UpdateDeviceConfigurationDataAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 1);

                return py::convert(winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration::UpdateDeviceConfigurationDataAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_SecondaryAuthenticationFactorRegistration(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SecondaryAuthenticationFactorRegistration(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::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SecondaryAuthenticationFactorRegistration[] = {
        { "abort_registering_device_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_AbortRegisteringDeviceAsync), METH_VARARGS, nullptr },
        { "find_all_registered_device_info_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_FindAllRegisteredDeviceInfoAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "finish_registering_device_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_FinishRegisteringDeviceAsync), METH_VARARGS, nullptr },
        { "is_device_presence_monitoring_supported", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_IsDevicePresenceMonitoringSupported), METH_VARARGS | METH_STATIC, nullptr },
        { "register_device_presence_monitoring_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_RegisterDevicePresenceMonitoringAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "request_start_registering_device_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_RequestStartRegisteringDeviceAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister_device_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_UnregisterDeviceAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister_device_presence_monitoring_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_UnregisterDevicePresenceMonitoringAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "update_device_configuration_data_async", reinterpret_cast<PyCFunction>(SecondaryAuthenticationFactorRegistration_UpdateDeviceConfigurationDataAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "_assign_array_", _assign_array_SecondaryAuthenticationFactorRegistration, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorRegistration), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorRegistration[] = {
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorRegistration[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SecondaryAuthenticationFactorRegistration) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SecondaryAuthenticationFactorRegistration) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SecondaryAuthenticationFactorRegistration) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SecondaryAuthenticationFactorRegistration) },
        { },
    };

    static PyType_Spec type_spec_SecondaryAuthenticationFactorRegistration =
    {
        "_winsdk_Windows_Security_Authentication_Identity_Provider.SecondaryAuthenticationFactorRegistration",
        sizeof(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SecondaryAuthenticationFactorRegistration
    };

    // ----- SecondaryAuthenticationFactorRegistrationResult class --------------------
    static constexpr const char* const type_name_SecondaryAuthenticationFactorRegistrationResult = "SecondaryAuthenticationFactorRegistrationResult";

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

    static void _dealloc_SecondaryAuthenticationFactorRegistrationResult(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SecondaryAuthenticationFactorRegistrationResult_get_Registration(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationResult", L"Registration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* SecondaryAuthenticationFactorRegistrationResult_get_Status(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationResult", L"Status"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_SecondaryAuthenticationFactorRegistrationResult(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SecondaryAuthenticationFactorRegistrationResult(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::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SecondaryAuthenticationFactorRegistrationResult[] = {
        { "_assign_array_", _assign_array_SecondaryAuthenticationFactorRegistrationResult, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorRegistrationResult), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorRegistrationResult[] = {
        { "registration", reinterpret_cast<getter>(SecondaryAuthenticationFactorRegistrationResult_get_Registration), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(SecondaryAuthenticationFactorRegistrationResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorRegistrationResult[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SecondaryAuthenticationFactorRegistrationResult) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SecondaryAuthenticationFactorRegistrationResult) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SecondaryAuthenticationFactorRegistrationResult) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SecondaryAuthenticationFactorRegistrationResult) },
        { },
    };

    static PyType_Spec type_spec_SecondaryAuthenticationFactorRegistrationResult =
    {
        "_winsdk_Windows_Security_Authentication_Identity_Provider.SecondaryAuthenticationFactorRegistrationResult",
        sizeof(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SecondaryAuthenticationFactorRegistrationResult
    };

    // ----- Windows.Security.Authentication.Identity.Provider Initialization --------------------
    PyDoc_STRVAR(module_doc, "Windows::Security::Authentication::Identity::Provider");

    static PyMethodDef module_methods[] = {
        {"_register_SecondaryAuthenticationFactorAuthenticationMessage", register_SecondaryAuthenticationFactorAuthenticationMessage, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorAuthenticationScenario", register_SecondaryAuthenticationFactorAuthenticationScenario, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorAuthenticationStage", register_SecondaryAuthenticationFactorAuthenticationStage, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorAuthenticationStatus", register_SecondaryAuthenticationFactorAuthenticationStatus, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorDeviceCapabilities", register_SecondaryAuthenticationFactorDeviceCapabilities, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorDeviceFindScope", register_SecondaryAuthenticationFactorDeviceFindScope, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorDevicePresence", register_SecondaryAuthenticationFactorDevicePresence, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorDevicePresenceMonitoringMode", register_SecondaryAuthenticationFactorDevicePresenceMonitoringMode, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus", register_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorFinishAuthenticationStatus", register_SecondaryAuthenticationFactorFinishAuthenticationStatus, METH_O, "registers type"},
        {"_register_SecondaryAuthenticationFactorRegistrationStatus", register_SecondaryAuthenticationFactorRegistrationStatus, METH_O, "registers type"},
        {}};


    static int module_traverse(PyObject* module, visitproc visit, void* arg) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthenticationMessage);
        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthenticationScenario);
        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthenticationStage);
        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthenticationStatus);
        Py_VISIT(state->type_SecondaryAuthenticationFactorDeviceCapabilities);
        Py_VISIT(state->type_SecondaryAuthenticationFactorDeviceFindScope);
        Py_VISIT(state->type_SecondaryAuthenticationFactorDevicePresence);
        Py_VISIT(state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringMode);
        Py_VISIT(state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus);
        Py_VISIT(state->type_SecondaryAuthenticationFactorFinishAuthenticationStatus);
        Py_VISIT(state->type_SecondaryAuthenticationFactorRegistrationStatus);
        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthentication);
        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthenticationResult);
        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs);
        Py_VISIT(state->type_SecondaryAuthenticationFactorAuthenticationStageInfo);
        Py_VISIT(state->type_SecondaryAuthenticationFactorInfo);
        Py_VISIT(state->type_SecondaryAuthenticationFactorRegistration);
        Py_VISIT(state->type_SecondaryAuthenticationFactorRegistrationResult);

        return 0;
    }

    static int module_clear(PyObject* module) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthenticationMessage);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthenticationScenario);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthenticationStage);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthenticationStatus);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorDeviceCapabilities);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorDeviceFindScope);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorDevicePresence);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringMode);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorFinishAuthenticationStatus);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorRegistrationStatus);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthentication);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthenticationResult);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorAuthenticationStageInfo);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorInfo);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorRegistration);
        Py_CLEAR(state->type_SecondaryAuthenticationFactorRegistrationResult);

        return 0;
    }


    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Security_Authentication_Identity_Provider",
           module_doc,
           sizeof(module_state),
           module_methods,
           nullptr,
           module_traverse,
           module_clear,
           nullptr};

} // py::cpp::Windows::Security::Authentication::Identity::Provider

PyMODINIT_FUNC PyInit__winsdk_Windows_Security_Authentication_Identity_Provider(void) noexcept
{
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

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

    if (!module)
    {
        return nullptr;
    }

    auto object_type = py::get_python_type<py::Object>();
    if (!object_type)
    {
        return nullptr;
    }

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

    if (!bases)
    {
        return nullptr;
    }

    py::pyobj_handle collections_abc_module{PyImport_ImportModule("collections.abc")};

    if (!collections_abc_module)
    {
        return nullptr;
    }

    py::pyobj_handle sequence_type{PyObject_GetAttrString(collections_abc_module.get(), "Sequence")};

    if (!sequence_type)
    {
        return nullptr;
    }

    py::pyobj_handle sequence_bases{PyTuple_Pack(2, object_type, sequence_type.get())};

    if (!sequence_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_sequence_type{PyObject_GetAttrString(collections_abc_module.get(), "MutableSequence")};

    if (!mutable_sequence_type)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_sequence_bases{PyTuple_Pack(2, object_type, mutable_sequence_type.get())};

    if (!mutable_sequence_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mapping_type{PyObject_GetAttrString(collections_abc_module.get(), "Mapping")};

    if (!mapping_type)
    {
        return nullptr;
    }

    py::pyobj_handle mapping_bases{PyTuple_Pack(2, object_type, mapping_type.get())};

    if (!mapping_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_mapping_type{PyObject_GetAttrString(collections_abc_module.get(), "MutableMapping")};

    if (!mutable_mapping_type)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_mapping_bases{PyTuple_Pack(2, object_type, mutable_mapping_type.get())};

    if (!mutable_mapping_bases)
    {
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module.get()));
    assert(state);

    state->type_SecondaryAuthenticationFactorAuthentication = py::register_python_type(module.get(), type_name_SecondaryAuthenticationFactorAuthentication, &type_spec_SecondaryAuthenticationFactorAuthentication, bases.get(), nullptr);
    if (!state->type_SecondaryAuthenticationFactorAuthentication)
    {
        return nullptr;
    }

    state->type_SecondaryAuthenticationFactorAuthenticationResult = py::register_python_type(module.get(), type_name_SecondaryAuthenticationFactorAuthenticationResult, &type_spec_SecondaryAuthenticationFactorAuthenticationResult, bases.get(), nullptr);
    if (!state->type_SecondaryAuthenticationFactorAuthenticationResult)
    {
        return nullptr;
    }

    state->type_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs = py::register_python_type(module.get(), type_name_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs, &type_spec_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs, bases.get(), nullptr);
    if (!state->type_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs)
    {
        return nullptr;
    }

    state->type_SecondaryAuthenticationFactorAuthenticationStageInfo = py::register_python_type(module.get(), type_name_SecondaryAuthenticationFactorAuthenticationStageInfo, &type_spec_SecondaryAuthenticationFactorAuthenticationStageInfo, bases.get(), nullptr);
    if (!state->type_SecondaryAuthenticationFactorAuthenticationStageInfo)
    {
        return nullptr;
    }

    state->type_SecondaryAuthenticationFactorInfo = py::register_python_type(module.get(), type_name_SecondaryAuthenticationFactorInfo, &type_spec_SecondaryAuthenticationFactorInfo, bases.get(), nullptr);
    if (!state->type_SecondaryAuthenticationFactorInfo)
    {
        return nullptr;
    }

    state->type_SecondaryAuthenticationFactorRegistration = py::register_python_type(module.get(), type_name_SecondaryAuthenticationFactorRegistration, &type_spec_SecondaryAuthenticationFactorRegistration, bases.get(), nullptr);
    if (!state->type_SecondaryAuthenticationFactorRegistration)
    {
        return nullptr;
    }

    state->type_SecondaryAuthenticationFactorRegistrationResult = py::register_python_type(module.get(), type_name_SecondaryAuthenticationFactorRegistrationResult, &type_spec_SecondaryAuthenticationFactorRegistrationResult, bases.get(), nullptr);
    if (!state->type_SecondaryAuthenticationFactorRegistrationResult)
    {
        return nullptr;
    }


    return module.detach();
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationMessage>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthenticationMessage;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationMessage is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationScenario>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthenticationScenario;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationScenario is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStage>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthenticationStage;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStage is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStatus>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthenticationStatus;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStatus is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDeviceCapabilities>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorDeviceCapabilities;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDeviceCapabilities is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDeviceFindScope>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorDeviceFindScope;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDeviceFindScope is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresence>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorDevicePresence;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresence is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresenceMonitoringMode>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringMode;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresenceMonitoringMode is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorFinishAuthenticationStatus>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorFinishAuthenticationStatus;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorFinishAuthenticationStatus is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationStatus>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorRegistrationStatus;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationStatus is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthentication;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthenticationResult;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorAuthenticationStageInfo;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorInfo;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorRegistration;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Security::Authentication::Identity::Provider;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Security::Authentication::Identity::Provider");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SecondaryAuthenticationFactorRegistrationResult;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult is not registered");
        return nullptr;
    }

    return python_type;
}
