text: // WARNING: Please don't edit this file. It was generated by Python/WinRT v1.0.0-beta.4
  
  #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);
  }
  