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.Devices.Input.Preview.h"
  
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDevicePreview>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherAddedPreviewEventArgs>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherRemovedPreviewEventArgs>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherUpdatedPreviewEventArgs>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs>::python_type;
  PyTypeObject* py::winrt_type<winrt::Windows::Devices::Input::Preview::GazePointPreview>::python_type;
  
  namespace py::cpp::Windows::Devices::Input::Preview
  {
      // ----- GazeDevicePreview class --------------------
      constexpr const char* const _type_name_GazeDevicePreview = "GazeDevicePreview";
  
      static PyObject* _new_GazeDevicePreview(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeDevicePreview);
          return nullptr;
      }
  
      static void _dealloc_GazeDevicePreview(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeDevicePreview_GetBooleanControlDescriptions(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 2)
          {
              try
              {
                  auto param0 = py::convert_to<uint16_t>(args, 0);
                  auto param1 = py::convert_to<uint16_t>(args, 1);
  
                  return py::convert(self->obj.GetBooleanControlDescriptions(param0, param1));
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeDevicePreview_GetNumericControlDescriptions(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 2)
          {
              try
              {
                  auto param0 = py::convert_to<uint16_t>(args, 0);
                  auto param1 = py::convert_to<uint16_t>(args, 1);
  
                  return py::convert(self->obj.GetNumericControlDescriptions(param0, param1));
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeDevicePreview_RequestCalibrationAsync(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 0)
          {
              try
              {
                  return py::convert(self->obj.RequestCalibrationAsync());
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeDevicePreview_get_CanTrackEyes(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.CanTrackEyes());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDevicePreview_get_CanTrackHead(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.CanTrackHead());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDevicePreview_get_ConfigurationState(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.ConfigurationState());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDevicePreview_get_Id(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Id());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeDevicePreview(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeDevicePreview>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeDevicePreview[] = {
          { "get_boolean_control_descriptions", reinterpret_cast<PyCFunction>(GazeDevicePreview_GetBooleanControlDescriptions), METH_VARARGS, nullptr },
          { "get_numeric_control_descriptions", reinterpret_cast<PyCFunction>(GazeDevicePreview_GetNumericControlDescriptions), METH_VARARGS, nullptr },
          { "request_calibration_async", reinterpret_cast<PyCFunction>(GazeDevicePreview_RequestCalibrationAsync), METH_VARARGS, nullptr },
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeDevicePreview), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeDevicePreview[] = {
          { "can_track_eyes", reinterpret_cast<getter>(GazeDevicePreview_get_CanTrackEyes), nullptr, nullptr, nullptr },
          { "can_track_head", reinterpret_cast<getter>(GazeDevicePreview_get_CanTrackHead), nullptr, nullptr, nullptr },
          { "configuration_state", reinterpret_cast<getter>(GazeDevicePreview_get_ConfigurationState), nullptr, nullptr, nullptr },
          { "id", reinterpret_cast<getter>(GazeDevicePreview_get_Id), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazeDevicePreview[] = 
      {
          { Py_tp_new, _new_GazeDevicePreview },
          { Py_tp_dealloc, _dealloc_GazeDevicePreview },
          { Py_tp_methods, _methods_GazeDevicePreview },
          { Py_tp_getset, _getset_GazeDevicePreview },
          { },
      };
  
      static PyType_Spec _type_spec_GazeDevicePreview =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeDevicePreview",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeDevicePreview),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeDevicePreview
      };
  
      // ----- GazeDeviceWatcherAddedPreviewEventArgs class --------------------
      constexpr const char* const _type_name_GazeDeviceWatcherAddedPreviewEventArgs = "GazeDeviceWatcherAddedPreviewEventArgs";
  
      static PyObject* _new_GazeDeviceWatcherAddedPreviewEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeDeviceWatcherAddedPreviewEventArgs);
          return nullptr;
      }
  
      static void _dealloc_GazeDeviceWatcherAddedPreviewEventArgs(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherAddedPreviewEventArgs* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeDeviceWatcherAddedPreviewEventArgs_get_Device(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherAddedPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Device());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeDeviceWatcherAddedPreviewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherAddedPreviewEventArgs>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeDeviceWatcherAddedPreviewEventArgs[] = {
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeDeviceWatcherAddedPreviewEventArgs), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeDeviceWatcherAddedPreviewEventArgs[] = {
          { "device", reinterpret_cast<getter>(GazeDeviceWatcherAddedPreviewEventArgs_get_Device), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazeDeviceWatcherAddedPreviewEventArgs[] = 
      {
          { Py_tp_new, _new_GazeDeviceWatcherAddedPreviewEventArgs },
          { Py_tp_dealloc, _dealloc_GazeDeviceWatcherAddedPreviewEventArgs },
          { Py_tp_methods, _methods_GazeDeviceWatcherAddedPreviewEventArgs },
          { Py_tp_getset, _getset_GazeDeviceWatcherAddedPreviewEventArgs },
          { },
      };
  
      static PyType_Spec _type_spec_GazeDeviceWatcherAddedPreviewEventArgs =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeDeviceWatcherAddedPreviewEventArgs",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherAddedPreviewEventArgs),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeDeviceWatcherAddedPreviewEventArgs
      };
  
      // ----- GazeDeviceWatcherPreview class --------------------
      constexpr const char* const _type_name_GazeDeviceWatcherPreview = "GazeDeviceWatcherPreview";
  
      static PyObject* _new_GazeDeviceWatcherPreview(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeDeviceWatcherPreview);
          return nullptr;
      }
  
      static void _dealloc_GazeDeviceWatcherPreview(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeDeviceWatcherPreview_Start(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 0)
          {
              try
              {
                  self->obj.Start();
                  Py_RETURN_NONE;
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_Stop(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 0)
          {
              try
              {
                  self->obj.Stop();
                  Py_RETURN_NONE;
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_add_Added(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview, winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherAddedPreviewEventArgs>>(arg);
  
              return py::convert(self->obj.Added(param0));
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_remove_Added(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::event_token>(arg);
  
              self->obj.Added(param0);
              Py_RETURN_NONE;
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_add_EnumerationCompleted(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview, winrt::Windows::Foundation::IInspectable>>(arg);
  
              return py::convert(self->obj.EnumerationCompleted(param0));
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_remove_EnumerationCompleted(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::event_token>(arg);
  
              self->obj.EnumerationCompleted(param0);
              Py_RETURN_NONE;
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_add_Removed(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview, winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherRemovedPreviewEventArgs>>(arg);
  
              return py::convert(self->obj.Removed(param0));
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_remove_Removed(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::event_token>(arg);
  
              self->obj.Removed(param0);
              Py_RETURN_NONE;
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_add_Updated(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview, winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherUpdatedPreviewEventArgs>>(arg);
  
              return py::convert(self->obj.Updated(param0));
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeDeviceWatcherPreview_remove_Updated(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::event_token>(arg);
  
              self->obj.Updated(param0);
              Py_RETURN_NONE;
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeDeviceWatcherPreview(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeDeviceWatcherPreview[] = {
          { "start", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_Start), METH_VARARGS, nullptr },
          { "stop", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_Stop), METH_VARARGS, nullptr },
          { "add_added", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_add_Added), METH_O, nullptr },
          { "remove_added", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_remove_Added), METH_O, nullptr },
          { "add_enumeration_completed", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_add_EnumerationCompleted), METH_O, nullptr },
          { "remove_enumeration_completed", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_remove_EnumerationCompleted), METH_O, nullptr },
          { "add_removed", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_add_Removed), METH_O, nullptr },
          { "remove_removed", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_remove_Removed), METH_O, nullptr },
          { "add_updated", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_add_Updated), METH_O, nullptr },
          { "remove_updated", reinterpret_cast<PyCFunction>(GazeDeviceWatcherPreview_remove_Updated), METH_O, nullptr },
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeDeviceWatcherPreview), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeDeviceWatcherPreview[] = {
          { }
      };
  
      static PyType_Slot _type_slots_GazeDeviceWatcherPreview[] = 
      {
          { Py_tp_new, _new_GazeDeviceWatcherPreview },
          { Py_tp_dealloc, _dealloc_GazeDeviceWatcherPreview },
          { Py_tp_methods, _methods_GazeDeviceWatcherPreview },
          { Py_tp_getset, _getset_GazeDeviceWatcherPreview },
          { },
      };
  
      static PyType_Spec _type_spec_GazeDeviceWatcherPreview =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeDeviceWatcherPreview",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeDeviceWatcherPreview
      };
  
      // ----- GazeDeviceWatcherRemovedPreviewEventArgs class --------------------
      constexpr const char* const _type_name_GazeDeviceWatcherRemovedPreviewEventArgs = "GazeDeviceWatcherRemovedPreviewEventArgs";
  
      static PyObject* _new_GazeDeviceWatcherRemovedPreviewEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeDeviceWatcherRemovedPreviewEventArgs);
          return nullptr;
      }
  
      static void _dealloc_GazeDeviceWatcherRemovedPreviewEventArgs(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherRemovedPreviewEventArgs* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeDeviceWatcherRemovedPreviewEventArgs_get_Device(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherRemovedPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Device());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeDeviceWatcherRemovedPreviewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherRemovedPreviewEventArgs>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeDeviceWatcherRemovedPreviewEventArgs[] = {
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeDeviceWatcherRemovedPreviewEventArgs), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeDeviceWatcherRemovedPreviewEventArgs[] = {
          { "device", reinterpret_cast<getter>(GazeDeviceWatcherRemovedPreviewEventArgs_get_Device), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazeDeviceWatcherRemovedPreviewEventArgs[] = 
      {
          { Py_tp_new, _new_GazeDeviceWatcherRemovedPreviewEventArgs },
          { Py_tp_dealloc, _dealloc_GazeDeviceWatcherRemovedPreviewEventArgs },
          { Py_tp_methods, _methods_GazeDeviceWatcherRemovedPreviewEventArgs },
          { Py_tp_getset, _getset_GazeDeviceWatcherRemovedPreviewEventArgs },
          { },
      };
  
      static PyType_Spec _type_spec_GazeDeviceWatcherRemovedPreviewEventArgs =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeDeviceWatcherRemovedPreviewEventArgs",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherRemovedPreviewEventArgs),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeDeviceWatcherRemovedPreviewEventArgs
      };
  
      // ----- GazeDeviceWatcherUpdatedPreviewEventArgs class --------------------
      constexpr const char* const _type_name_GazeDeviceWatcherUpdatedPreviewEventArgs = "GazeDeviceWatcherUpdatedPreviewEventArgs";
  
      static PyObject* _new_GazeDeviceWatcherUpdatedPreviewEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeDeviceWatcherUpdatedPreviewEventArgs);
          return nullptr;
      }
  
      static void _dealloc_GazeDeviceWatcherUpdatedPreviewEventArgs(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherUpdatedPreviewEventArgs* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeDeviceWatcherUpdatedPreviewEventArgs_get_Device(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherUpdatedPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Device());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeDeviceWatcherUpdatedPreviewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherUpdatedPreviewEventArgs>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeDeviceWatcherUpdatedPreviewEventArgs[] = {
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeDeviceWatcherUpdatedPreviewEventArgs), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeDeviceWatcherUpdatedPreviewEventArgs[] = {
          { "device", reinterpret_cast<getter>(GazeDeviceWatcherUpdatedPreviewEventArgs_get_Device), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazeDeviceWatcherUpdatedPreviewEventArgs[] = 
      {
          { Py_tp_new, _new_GazeDeviceWatcherUpdatedPreviewEventArgs },
          { Py_tp_dealloc, _dealloc_GazeDeviceWatcherUpdatedPreviewEventArgs },
          { Py_tp_methods, _methods_GazeDeviceWatcherUpdatedPreviewEventArgs },
          { Py_tp_getset, _getset_GazeDeviceWatcherUpdatedPreviewEventArgs },
          { },
      };
  
      static PyType_Spec _type_spec_GazeDeviceWatcherUpdatedPreviewEventArgs =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeDeviceWatcherUpdatedPreviewEventArgs",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeDeviceWatcherUpdatedPreviewEventArgs),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeDeviceWatcherUpdatedPreviewEventArgs
      };
  
      // ----- GazeEnteredPreviewEventArgs class --------------------
      constexpr const char* const _type_name_GazeEnteredPreviewEventArgs = "GazeEnteredPreviewEventArgs";
  
      static PyObject* _new_GazeEnteredPreviewEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeEnteredPreviewEventArgs);
          return nullptr;
      }
  
      static void _dealloc_GazeEnteredPreviewEventArgs(py::wrapper::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeEnteredPreviewEventArgs_get_Handled(py::wrapper::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Handled());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static int GazeEnteredPreviewEventArgs_put_Handled(py::wrapper::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
      {
          if (arg == nullptr)
          {
              PyErr_SetString(PyExc_TypeError, "property delete not supported");
              return -1;
          }
  
          try
          {
              auto param0 = py::convert_to<bool>(arg);
  
              self->obj.Handled(param0);
              return 0;
          }
          catch (...)
          {
              py::to_PyErr();
              return -1;
          }
      }
  
      static PyObject* GazeEnteredPreviewEventArgs_get_CurrentPoint(py::wrapper::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.CurrentPoint());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeEnteredPreviewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeEnteredPreviewEventArgs[] = {
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeEnteredPreviewEventArgs), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeEnteredPreviewEventArgs[] = {
          { "handled", reinterpret_cast<getter>(GazeEnteredPreviewEventArgs_get_Handled), reinterpret_cast<setter>(GazeEnteredPreviewEventArgs_put_Handled), nullptr, nullptr },
          { "current_point", reinterpret_cast<getter>(GazeEnteredPreviewEventArgs_get_CurrentPoint), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazeEnteredPreviewEventArgs[] = 
      {
          { Py_tp_new, _new_GazeEnteredPreviewEventArgs },
          { Py_tp_dealloc, _dealloc_GazeEnteredPreviewEventArgs },
          { Py_tp_methods, _methods_GazeEnteredPreviewEventArgs },
          { Py_tp_getset, _getset_GazeEnteredPreviewEventArgs },
          { },
      };
  
      static PyType_Spec _type_spec_GazeEnteredPreviewEventArgs =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeEnteredPreviewEventArgs",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeEnteredPreviewEventArgs
      };
  
      // ----- GazeExitedPreviewEventArgs class --------------------
      constexpr const char* const _type_name_GazeExitedPreviewEventArgs = "GazeExitedPreviewEventArgs";
  
      static PyObject* _new_GazeExitedPreviewEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeExitedPreviewEventArgs);
          return nullptr;
      }
  
      static void _dealloc_GazeExitedPreviewEventArgs(py::wrapper::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeExitedPreviewEventArgs_get_Handled(py::wrapper::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Handled());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static int GazeExitedPreviewEventArgs_put_Handled(py::wrapper::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
      {
          if (arg == nullptr)
          {
              PyErr_SetString(PyExc_TypeError, "property delete not supported");
              return -1;
          }
  
          try
          {
              auto param0 = py::convert_to<bool>(arg);
  
              self->obj.Handled(param0);
              return 0;
          }
          catch (...)
          {
              py::to_PyErr();
              return -1;
          }
      }
  
      static PyObject* GazeExitedPreviewEventArgs_get_CurrentPoint(py::wrapper::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.CurrentPoint());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeExitedPreviewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeExitedPreviewEventArgs[] = {
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeExitedPreviewEventArgs), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeExitedPreviewEventArgs[] = {
          { "handled", reinterpret_cast<getter>(GazeExitedPreviewEventArgs_get_Handled), reinterpret_cast<setter>(GazeExitedPreviewEventArgs_put_Handled), nullptr, nullptr },
          { "current_point", reinterpret_cast<getter>(GazeExitedPreviewEventArgs_get_CurrentPoint), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazeExitedPreviewEventArgs[] = 
      {
          { Py_tp_new, _new_GazeExitedPreviewEventArgs },
          { Py_tp_dealloc, _dealloc_GazeExitedPreviewEventArgs },
          { Py_tp_methods, _methods_GazeExitedPreviewEventArgs },
          { Py_tp_getset, _getset_GazeExitedPreviewEventArgs },
          { },
      };
  
      static PyType_Spec _type_spec_GazeExitedPreviewEventArgs =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeExitedPreviewEventArgs",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeExitedPreviewEventArgs
      };
  
      // ----- GazeInputSourcePreview class --------------------
      constexpr const char* const _type_name_GazeInputSourcePreview = "GazeInputSourcePreview";
  
      static PyObject* _new_GazeInputSourcePreview(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeInputSourcePreview);
          return nullptr;
      }
  
      static void _dealloc_GazeInputSourcePreview(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeInputSourcePreview_CreateWatcher(PyObject* /*unused*/, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 0)
          {
              try
              {
                  return py::convert(winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview::CreateWatcher());
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeInputSourcePreview_GetForCurrentView(PyObject* /*unused*/, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 0)
          {
              try
              {
                  return py::convert(winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview::GetForCurrentView());
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeInputSourcePreview_add_GazeEntered(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview, winrt::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs>>(arg);
  
              return py::convert(self->obj.GazeEntered(param0));
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeInputSourcePreview_remove_GazeEntered(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::event_token>(arg);
  
              self->obj.GazeEntered(param0);
              Py_RETURN_NONE;
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeInputSourcePreview_add_GazeExited(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview, winrt::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs>>(arg);
  
              return py::convert(self->obj.GazeExited(param0));
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeInputSourcePreview_remove_GazeExited(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::event_token>(arg);
  
              self->obj.GazeExited(param0);
              Py_RETURN_NONE;
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeInputSourcePreview_add_GazeMoved(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview, winrt::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs>>(arg);
  
              return py::convert(self->obj.GazeMoved(param0));
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazeInputSourcePreview_remove_GazeMoved(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview* self, PyObject* arg) noexcept
      {
          try
          {
              auto param0 = py::convert_to<winrt::event_token>(arg);
  
              self->obj.GazeMoved(param0);
              Py_RETURN_NONE;
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeInputSourcePreview(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeInputSourcePreview[] = {
          { "create_watcher", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_CreateWatcher), METH_VARARGS | METH_STATIC, nullptr },
          { "get_for_current_view", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_GetForCurrentView), METH_VARARGS | METH_STATIC, nullptr },
          { "add_gaze_entered", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_add_GazeEntered), METH_O, nullptr },
          { "remove_gaze_entered", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_remove_GazeEntered), METH_O, nullptr },
          { "add_gaze_exited", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_add_GazeExited), METH_O, nullptr },
          { "remove_gaze_exited", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_remove_GazeExited), METH_O, nullptr },
          { "add_gaze_moved", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_add_GazeMoved), METH_O, nullptr },
          { "remove_gaze_moved", reinterpret_cast<PyCFunction>(GazeInputSourcePreview_remove_GazeMoved), METH_O, nullptr },
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeInputSourcePreview), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeInputSourcePreview[] = {
          { }
      };
  
      static PyType_Slot _type_slots_GazeInputSourcePreview[] = 
      {
          { Py_tp_new, _new_GazeInputSourcePreview },
          { Py_tp_dealloc, _dealloc_GazeInputSourcePreview },
          { Py_tp_methods, _methods_GazeInputSourcePreview },
          { Py_tp_getset, _getset_GazeInputSourcePreview },
          { },
      };
  
      static PyType_Spec _type_spec_GazeInputSourcePreview =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeInputSourcePreview",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeInputSourcePreview),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeInputSourcePreview
      };
  
      // ----- GazeMovedPreviewEventArgs class --------------------
      constexpr const char* const _type_name_GazeMovedPreviewEventArgs = "GazeMovedPreviewEventArgs";
  
      static PyObject* _new_GazeMovedPreviewEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazeMovedPreviewEventArgs);
          return nullptr;
      }
  
      static void _dealloc_GazeMovedPreviewEventArgs(py::wrapper::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazeMovedPreviewEventArgs_GetIntermediatePoints(py::wrapper::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs* self, PyObject* args) noexcept
      {
          Py_ssize_t arg_count = PyTuple_Size(args);
  
          if (arg_count == 0)
          {
              try
              {
                  return py::convert(self->obj.GetIntermediatePoints());
              }
              catch (...)
              {
                  py::to_PyErr();
                  return nullptr;
              }
          }
          else
          {
              py::set_invalid_arg_count_error(arg_count);
              return nullptr;
          }
      }
  
      static PyObject* GazeMovedPreviewEventArgs_get_Handled(py::wrapper::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Handled());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static int GazeMovedPreviewEventArgs_put_Handled(py::wrapper::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
      {
          if (arg == nullptr)
          {
              PyErr_SetString(PyExc_TypeError, "property delete not supported");
              return -1;
          }
  
          try
          {
              auto param0 = py::convert_to<bool>(arg);
  
              self->obj.Handled(param0);
              return 0;
          }
          catch (...)
          {
              py::to_PyErr();
              return -1;
          }
      }
  
      static PyObject* GazeMovedPreviewEventArgs_get_CurrentPoint(py::wrapper::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.CurrentPoint());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazeMovedPreviewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazeMovedPreviewEventArgs[] = {
          { "get_intermediate_points", reinterpret_cast<PyCFunction>(GazeMovedPreviewEventArgs_GetIntermediatePoints), METH_VARARGS, nullptr },
          { "_from", reinterpret_cast<PyCFunction>(_from_GazeMovedPreviewEventArgs), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazeMovedPreviewEventArgs[] = {
          { "handled", reinterpret_cast<getter>(GazeMovedPreviewEventArgs_get_Handled), reinterpret_cast<setter>(GazeMovedPreviewEventArgs_put_Handled), nullptr, nullptr },
          { "current_point", reinterpret_cast<getter>(GazeMovedPreviewEventArgs_get_CurrentPoint), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazeMovedPreviewEventArgs[] = 
      {
          { Py_tp_new, _new_GazeMovedPreviewEventArgs },
          { Py_tp_dealloc, _dealloc_GazeMovedPreviewEventArgs },
          { Py_tp_methods, _methods_GazeMovedPreviewEventArgs },
          { Py_tp_getset, _getset_GazeMovedPreviewEventArgs },
          { },
      };
  
      static PyType_Spec _type_spec_GazeMovedPreviewEventArgs =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazeMovedPreviewEventArgs",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazeMovedPreviewEventArgs
      };
  
      // ----- GazePointPreview class --------------------
      constexpr const char* const _type_name_GazePointPreview = "GazePointPreview";
  
      static PyObject* _new_GazePointPreview(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
      {
          py::set_invalid_activation_error(_type_name_GazePointPreview);
          return nullptr;
      }
  
      static void _dealloc_GazePointPreview(py::wrapper::Windows::Devices::Input::Preview::GazePointPreview* self)
      {
          auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
          py::wrapped_instance(hash_value, nullptr);
          self->obj = nullptr;
      }
  
      static PyObject* GazePointPreview_get_EyeGazePosition(py::wrapper::Windows::Devices::Input::Preview::GazePointPreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.EyeGazePosition());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazePointPreview_get_HeadGazePosition(py::wrapper::Windows::Devices::Input::Preview::GazePointPreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.HeadGazePosition());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazePointPreview_get_HidInputReport(py::wrapper::Windows::Devices::Input::Preview::GazePointPreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.HidInputReport());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazePointPreview_get_SourceDevice(py::wrapper::Windows::Devices::Input::Preview::GazePointPreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.SourceDevice());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* GazePointPreview_get_Timestamp(py::wrapper::Windows::Devices::Input::Preview::GazePointPreview* self, void* /*unused*/) noexcept
      {
          try
          {
              return py::convert(self->obj.Timestamp());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyObject* _from_GazePointPreview(PyObject* /*unused*/, PyObject* arg) noexcept
      {
          try
          {
              auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
              return py::convert(return_value.as<winrt::Windows::Devices::Input::Preview::GazePointPreview>());
          }
          catch (...)
          {
              py::to_PyErr();
              return nullptr;
          }
      }
  
      static PyMethodDef _methods_GazePointPreview[] = {
          { "_from", reinterpret_cast<PyCFunction>(_from_GazePointPreview), METH_O | METH_STATIC, nullptr },
          { }
      };
  
      static PyGetSetDef _getset_GazePointPreview[] = {
          { "eye_gaze_position", reinterpret_cast<getter>(GazePointPreview_get_EyeGazePosition), nullptr, nullptr, nullptr },
          { "head_gaze_position", reinterpret_cast<getter>(GazePointPreview_get_HeadGazePosition), nullptr, nullptr, nullptr },
          { "hid_input_report", reinterpret_cast<getter>(GazePointPreview_get_HidInputReport), nullptr, nullptr, nullptr },
          { "source_device", reinterpret_cast<getter>(GazePointPreview_get_SourceDevice), nullptr, nullptr, nullptr },
          { "timestamp", reinterpret_cast<getter>(GazePointPreview_get_Timestamp), nullptr, nullptr, nullptr },
          { }
      };
  
      static PyType_Slot _type_slots_GazePointPreview[] = 
      {
          { Py_tp_new, _new_GazePointPreview },
          { Py_tp_dealloc, _dealloc_GazePointPreview },
          { Py_tp_methods, _methods_GazePointPreview },
          { Py_tp_getset, _getset_GazePointPreview },
          { },
      };
  
      static PyType_Spec _type_spec_GazePointPreview =
      {
          "_winsdk_Windows_Devices_Input_Preview.GazePointPreview",
          sizeof(py::wrapper::Windows::Devices::Input::Preview::GazePointPreview),
          0,
          Py_TPFLAGS_DEFAULT,
          _type_slots_GazePointPreview
      };
  
      // ----- Windows.Devices.Input.Preview Initialization --------------------
      static int module_exec(PyObject* module) noexcept
      {
          try
          {
              py::pyobj_handle bases { PyTuple_Pack(1, py::winrt_type<py::Object>::python_type) };
  
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDevicePreview>::python_type = py::register_python_type(module, _type_name_GazeDevicePreview, &_type_spec_GazeDevicePreview, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherAddedPreviewEventArgs>::python_type = py::register_python_type(module, _type_name_GazeDeviceWatcherAddedPreviewEventArgs, &_type_spec_GazeDeviceWatcherAddedPreviewEventArgs, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherPreview>::python_type = py::register_python_type(module, _type_name_GazeDeviceWatcherPreview, &_type_spec_GazeDeviceWatcherPreview, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherRemovedPreviewEventArgs>::python_type = py::register_python_type(module, _type_name_GazeDeviceWatcherRemovedPreviewEventArgs, &_type_spec_GazeDeviceWatcherRemovedPreviewEventArgs, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeDeviceWatcherUpdatedPreviewEventArgs>::python_type = py::register_python_type(module, _type_name_GazeDeviceWatcherUpdatedPreviewEventArgs, &_type_spec_GazeDeviceWatcherUpdatedPreviewEventArgs, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeEnteredPreviewEventArgs>::python_type = py::register_python_type(module, _type_name_GazeEnteredPreviewEventArgs, &_type_spec_GazeEnteredPreviewEventArgs, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeExitedPreviewEventArgs>::python_type = py::register_python_type(module, _type_name_GazeExitedPreviewEventArgs, &_type_spec_GazeExitedPreviewEventArgs, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeInputSourcePreview>::python_type = py::register_python_type(module, _type_name_GazeInputSourcePreview, &_type_spec_GazeInputSourcePreview, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazeMovedPreviewEventArgs>::python_type = py::register_python_type(module, _type_name_GazeMovedPreviewEventArgs, &_type_spec_GazeMovedPreviewEventArgs, bases.get());
              py::winrt_type<winrt::Windows::Devices::Input::Preview::GazePointPreview>::python_type = py::register_python_type(module, _type_name_GazePointPreview, &_type_spec_GazePointPreview, bases.get());
  
              return 0;
          }
          catch (...)
          {
              py::to_PyErr();
              return -1;
          }
      }
  
      static PyModuleDef_Slot module_slots[] = {{Py_mod_exec, module_exec}, {}};
  
      PyDoc_STRVAR(module_doc, "Windows.Devices.Input.Preview");
  
      static PyModuleDef module_def
          = {PyModuleDef_HEAD_INIT,
             "_winsdk_Windows_Devices_Input_Preview",
             module_doc,
             0,
             nullptr,
             module_slots,
             nullptr,
             nullptr,
             nullptr};
  } // py::cpp::Windows::Devices::Input::Preview
  
  PyMODINIT_FUNC
  PyInit__winsdk_Windows_Devices_Input_Preview (void) noexcept
  {
      return PyModuleDef_Init(&py::cpp::Windows::Devices::Input::Preview::module_def);
  }
  