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

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

PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult>::python_type;

namespace py::cpp::Windows::Security::Authentication::Identity::Provider
{
    // ----- SecondaryAuthenticationFactorAuthentication class --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

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

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

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

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::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
    {
        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
    {
        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
    {
        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
    {
        try
        {
            return py::convert(self->obj.SessionNonce());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SecondaryAuthenticationFactorAuthentication_add_AuthenticationStageChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        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
    {
        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* _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 },
        { "_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, _new_SecondaryAuthenticationFactorAuthentication },
        { Py_tp_dealloc, _dealloc_SecondaryAuthenticationFactorAuthentication },
        { Py_tp_methods, _methods_SecondaryAuthenticationFactorAuthentication },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SecondaryAuthenticationFactorAuthenticationResult_get_Authentication(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult* self, void* /*unused*/) noexcept
    {
        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
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_SecondaryAuthenticationFactorAuthenticationResult },
        { Py_tp_dealloc, _dealloc_SecondaryAuthenticationFactorAuthenticationResult },
        { Py_tp_methods, _methods_SecondaryAuthenticationFactorAuthenticationResult },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs_get_StageInfo(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.StageInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs },
        { Py_tp_dealloc, _dealloc_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs },
        { Py_tp_methods, _methods_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SecondaryAuthenticationFactorAuthenticationStageInfo_get_DeviceId(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo* self, void* /*unused*/) noexcept
    {
        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
    {
        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
    {
        try
        {
            return py::convert(self->obj.Stage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_SecondaryAuthenticationFactorAuthenticationStageInfo },
        { Py_tp_dealloc, _dealloc_SecondaryAuthenticationFactorAuthenticationStageInfo },
        { Py_tp_methods, _methods_SecondaryAuthenticationFactorAuthenticationStageInfo },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

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

    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 },
        { "_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, _new_SecondaryAuthenticationFactorInfo },
        { Py_tp_dealloc, _dealloc_SecondaryAuthenticationFactorInfo },
        { Py_tp_methods, _methods_SecondaryAuthenticationFactorInfo },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

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

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

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

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

        if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::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)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

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

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::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* _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 },
        { "_from", reinterpret_cast<PyCFunction>(_from_SecondaryAuthenticationFactorRegistration), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SecondaryAuthenticationFactorRegistration[] = {
        { }
    };

    static PyType_Slot _type_slots_SecondaryAuthenticationFactorRegistration[] = 
    {
        { Py_tp_new, _new_SecondaryAuthenticationFactorRegistration },
        { Py_tp_dealloc, _dealloc_SecondaryAuthenticationFactorRegistration },
        { Py_tp_methods, _methods_SecondaryAuthenticationFactorRegistration },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SecondaryAuthenticationFactorRegistrationResult_get_Registration(py::wrapper::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult* self, void* /*unused*/) noexcept
    {
        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
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_SecondaryAuthenticationFactorRegistrationResult },
        { Py_tp_dealloc, _dealloc_SecondaryAuthenticationFactorRegistrationResult },
        { Py_tp_methods, _methods_SecondaryAuthenticationFactorRegistrationResult },
        { Py_tp_getset, _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 --------------------
    static int module_exec(PyObject* module) noexcept
    {
        try
        {
            py::pyobj_handle bases { PyTuple_Pack(1, py::winrt_type<py::Object>::python_type) };

            py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthentication>::python_type = py::register_python_type(module, _type_name_SecondaryAuthenticationFactorAuthentication, &_type_spec_SecondaryAuthenticationFactorAuthentication, bases.get());
            py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationResult>::python_type = py::register_python_type(module, _type_name_SecondaryAuthenticationFactorAuthenticationResult, &_type_spec_SecondaryAuthenticationFactorAuthenticationResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>::python_type = py::register_python_type(module, _type_name_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs, &_type_spec_SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorAuthenticationStageInfo>::python_type = py::register_python_type(module, _type_name_SecondaryAuthenticationFactorAuthenticationStageInfo, &_type_spec_SecondaryAuthenticationFactorAuthenticationStageInfo, bases.get());
            py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorInfo>::python_type = py::register_python_type(module, _type_name_SecondaryAuthenticationFactorInfo, &_type_spec_SecondaryAuthenticationFactorInfo, bases.get());
            py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistration>::python_type = py::register_python_type(module, _type_name_SecondaryAuthenticationFactorRegistration, &_type_spec_SecondaryAuthenticationFactorRegistration, bases.get());
            py::winrt_type<winrt::Windows::Security::Authentication::Identity::Provider::SecondaryAuthenticationFactorRegistrationResult>::python_type = py::register_python_type(module, _type_name_SecondaryAuthenticationFactorRegistrationResult, &_type_spec_SecondaryAuthenticationFactorRegistrationResult, bases.get());

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

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

    PyDoc_STRVAR(module_doc, "Windows.Security.Authentication.Identity.Provider");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Security_Authentication_Identity_Provider",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::Security::Authentication::Identity::Provider

PyMODINIT_FUNC
PyInit__winsdk_Windows_Security_Authentication_Identity_Provider (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Security::Authentication::Identity::Provider::module_def);
}
