winrt-Windows.ApplicationModel.LockScreen 2.0.0b1__tar.gz

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: winrt-Windows.ApplicationModel.LockScreen
+Version: 2.0.0b1
+Summary: Python projection of Windows Runtime (WinRT) APIs
+License: MIT
+Project-URL: Repository, https://github.com/pywrint/pywrinrt
+Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Requires-Python: <3.13,>=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: all
+
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Windows.ApplicationModel.LockScreen
+
+Windows Runtime (WinRT) APIs for for the `Windows.ApplicationModel.LockScreen` namespace.
+
+This package provides the `winrt.windows.applicationmodel.lockscreen` module.

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/README.md

@@ -0,0 +1,7 @@
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Windows.ApplicationModel.LockScreen
+
+Windows Runtime (WinRT) APIs for for the `Windows.ApplicationModel.LockScreen` namespace.
+
+This package provides the `winrt.windows.applicationmodel.lockscreen` module.

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/all-requirements.txt

@@ -0,0 +1,5 @@
+# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+
+winrt-Windows.Foundation[all]==2.0.0-beta.1
+winrt-Windows.Foundation.Collections[all]==2.0.0-beta.1
+winrt-Windows.Storage.Streams[all]==2.0.0-beta.1

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/py.Windows.ApplicationModel.LockScreen.cpp

@@ -0,0 +1,1015 @@
+// WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+
+#include "py.Windows.ApplicationModel.LockScreen.h"
+
+
+namespace py::cpp::Windows::ApplicationModel::LockScreen
+{
+    // ----- LockApplicationHost class --------------------
+
+    static PyObject* _new_LockApplicationHost(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockApplicationHost>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockApplicationHost>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_LockApplicationHost(py::wrapper::Windows::ApplicationModel::LockScreen::LockApplicationHost* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* LockApplicationHost_GetForCurrentView(PyObject* /*unused*/, PyObject* args) noexcept
+    {
+        auto arg_count = PyTuple_Size(args);
+
+        if (arg_count == 0)
+        {
+            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.LockScreen.LockApplicationHost", L"GetForCurrentView", 0))
+            {
+                py::set_arg_count_version_error(0);
+                return nullptr;
+            }
+
+            try
+            {
+                return py::convert(winrt::Windows::ApplicationModel::LockScreen::LockApplicationHost::GetForCurrentView());
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockApplicationHost_RequestUnlock(py::wrapper::Windows::ApplicationModel::LockScreen::LockApplicationHost* self, PyObject* args) noexcept
+    {
+        auto arg_count = PyTuple_Size(args);
+
+        if (arg_count == 0)
+        {
+            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.LockScreen.LockApplicationHost", L"RequestUnlock", 0))
+            {
+                py::set_arg_count_version_error(0);
+                return nullptr;
+            }
+
+            try
+            {
+                self->obj.RequestUnlock();
+                Py_RETURN_NONE;
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockApplicationHost_add_Unlocking(py::wrapper::Windows::ApplicationModel::LockScreen::LockApplicationHost* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockApplicationHost", L"Unlocking"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::LockScreen::LockApplicationHost, winrt::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs>>(arg);
+
+            return py::convert(self->obj.Unlocking(param0));
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockApplicationHost_remove_Unlocking(py::wrapper::Windows::ApplicationModel::LockScreen::LockApplicationHost* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockApplicationHost", L"Unlocking"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::event_token>(arg);
+
+            self->obj.Unlocking(param0);
+            Py_RETURN_NONE;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_LockApplicationHost(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::LockScreen::LockApplicationHost>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_LockApplicationHost(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::ApplicationModel::LockScreen::LockApplicationHost>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_LockApplicationHost[] = {
+        { "request_unlock", reinterpret_cast<PyCFunction>(LockApplicationHost_RequestUnlock), METH_VARARGS, nullptr },
+        { "add_unlocking", reinterpret_cast<PyCFunction>(LockApplicationHost_add_Unlocking), METH_O, nullptr },
+        { "remove_unlocking", reinterpret_cast<PyCFunction>(LockApplicationHost_remove_Unlocking), METH_O, nullptr },
+        { "_assign_array_", _assign_array_LockApplicationHost, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_LockApplicationHost), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_LockApplicationHost[] = {
+        { }
+    };
+
+    static PyType_Slot _type_slots_LockApplicationHost[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_LockApplicationHost) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LockApplicationHost) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_LockApplicationHost) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_LockApplicationHost) },
+        { },
+    };
+
+    static PyType_Spec type_spec_LockApplicationHost =
+    {
+        "winrt._winrt_windows_applicationmodel_lockscreen.LockApplicationHost",
+        sizeof(py::wrapper::Windows::ApplicationModel::LockScreen::LockApplicationHost),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_LockApplicationHost
+    };
+
+    static PyGetSetDef getset_LockApplicationHost_Static[] = {
+        { }
+    };
+
+    static PyMethodDef methods_LockApplicationHost_Static[] = {
+        { "get_for_current_view", reinterpret_cast<PyCFunction>(LockApplicationHost_GetForCurrentView), METH_VARARGS, nullptr },
+        { }
+    };
+
+    static PyType_Slot type_slots_LockApplicationHost_Static[] = 
+    {
+        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
+        { Py_tp_getset, reinterpret_cast<void*>(getset_LockApplicationHost_Static) },
+        { Py_tp_methods, reinterpret_cast<void*>(methods_LockApplicationHost_Static) },
+        { }
+    };
+
+    static PyType_Spec type_spec_LockApplicationHost_Static =
+    {
+        "winrt._winrt_windows_applicationmodel_lockscreen.LockApplicationHost_Static",
+        static_cast<int>(PyType_Type.tp_basicsize),
+        static_cast<int>(PyType_Type.tp_itemsize),
+        Py_TPFLAGS_DEFAULT,
+        type_slots_LockApplicationHost_Static
+    };
+
+    // ----- LockScreenBadge class --------------------
+
+    static PyObject* _new_LockScreenBadge(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenBadge>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenBadge>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_LockScreenBadge(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenBadge* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* LockScreenBadge_LaunchApp(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenBadge* self, PyObject* args) noexcept
+    {
+        auto arg_count = PyTuple_Size(args);
+
+        if (arg_count == 0)
+        {
+            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.LockScreen.LockScreenBadge", L"LaunchApp", 0))
+            {
+                py::set_arg_count_version_error(0);
+                return nullptr;
+            }
+
+            try
+            {
+                self->obj.LaunchApp();
+                Py_RETURN_NONE;
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenBadge_get_AutomationName(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenBadge* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenBadge", L"AutomationName"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.AutomationName());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenBadge_get_Glyph(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenBadge* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenBadge", L"Glyph"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.Glyph());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenBadge_get_Logo(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenBadge* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenBadge", L"Logo"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.Logo());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenBadge_get_Number(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenBadge* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenBadge", L"Number"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.Number());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_LockScreenBadge(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::LockScreen::LockScreenBadge>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_LockScreenBadge(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::ApplicationModel::LockScreen::LockScreenBadge>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_LockScreenBadge[] = {
+        { "launch_app", reinterpret_cast<PyCFunction>(LockScreenBadge_LaunchApp), METH_VARARGS, nullptr },
+        { "_assign_array_", _assign_array_LockScreenBadge, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_LockScreenBadge), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_LockScreenBadge[] = {
+        { "automation_name", reinterpret_cast<getter>(LockScreenBadge_get_AutomationName), nullptr, nullptr, nullptr },
+        { "glyph", reinterpret_cast<getter>(LockScreenBadge_get_Glyph), nullptr, nullptr, nullptr },
+        { "logo", reinterpret_cast<getter>(LockScreenBadge_get_Logo), nullptr, nullptr, nullptr },
+        { "number", reinterpret_cast<getter>(LockScreenBadge_get_Number), nullptr, nullptr, nullptr },
+        { }
+    };
+
+    static PyType_Slot _type_slots_LockScreenBadge[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_LockScreenBadge) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LockScreenBadge) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_LockScreenBadge) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_LockScreenBadge) },
+        { },
+    };
+
+    static PyType_Spec type_spec_LockScreenBadge =
+    {
+        "winrt._winrt_windows_applicationmodel_lockscreen.LockScreenBadge",
+        sizeof(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenBadge),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_LockScreenBadge
+    };
+
+    // ----- LockScreenInfo class --------------------
+
+    static PyObject* _new_LockScreenInfo(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenInfo>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenInfo>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_LockScreenInfo(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* LockScreenInfo_get_AlarmIcon(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"AlarmIcon"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.AlarmIcon());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_get_Badges(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"Badges"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.Badges());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_get_DetailText(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"DetailText"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.DetailText());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_get_LockScreenImage(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"LockScreenImage"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.LockScreenImage());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_add_AlarmIconChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"AlarmIconChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::LockScreen::LockScreenInfo, winrt::Windows::Foundation::IInspectable>>(arg);
+
+            return py::convert(self->obj.AlarmIconChanged(param0));
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_remove_AlarmIconChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"AlarmIconChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::event_token>(arg);
+
+            self->obj.AlarmIconChanged(param0);
+            Py_RETURN_NONE;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_add_BadgesChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"BadgesChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::LockScreen::LockScreenInfo, winrt::Windows::Foundation::IInspectable>>(arg);
+
+            return py::convert(self->obj.BadgesChanged(param0));
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_remove_BadgesChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"BadgesChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::event_token>(arg);
+
+            self->obj.BadgesChanged(param0);
+            Py_RETURN_NONE;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_add_DetailTextChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"DetailTextChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::LockScreen::LockScreenInfo, winrt::Windows::Foundation::IInspectable>>(arg);
+
+            return py::convert(self->obj.DetailTextChanged(param0));
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_remove_DetailTextChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"DetailTextChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::event_token>(arg);
+
+            self->obj.DetailTextChanged(param0);
+            Py_RETURN_NONE;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_add_LockScreenImageChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"LockScreenImageChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::ApplicationModel::LockScreen::LockScreenInfo, winrt::Windows::Foundation::IInspectable>>(arg);
+
+            return py::convert(self->obj.LockScreenImageChanged(param0));
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenInfo_remove_LockScreenImageChanged(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.ApplicationModel.LockScreen.LockScreenInfo", L"LockScreenImageChanged"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::event_token>(arg);
+
+            self->obj.LockScreenImageChanged(param0);
+            Py_RETURN_NONE;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_LockScreenInfo(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::LockScreen::LockScreenInfo>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_LockScreenInfo(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::ApplicationModel::LockScreen::LockScreenInfo>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_LockScreenInfo[] = {
+        { "add_alarm_icon_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_add_AlarmIconChanged), METH_O, nullptr },
+        { "remove_alarm_icon_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_remove_AlarmIconChanged), METH_O, nullptr },
+        { "add_badges_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_add_BadgesChanged), METH_O, nullptr },
+        { "remove_badges_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_remove_BadgesChanged), METH_O, nullptr },
+        { "add_detail_text_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_add_DetailTextChanged), METH_O, nullptr },
+        { "remove_detail_text_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_remove_DetailTextChanged), METH_O, nullptr },
+        { "add_lock_screen_image_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_add_LockScreenImageChanged), METH_O, nullptr },
+        { "remove_lock_screen_image_changed", reinterpret_cast<PyCFunction>(LockScreenInfo_remove_LockScreenImageChanged), METH_O, nullptr },
+        { "_assign_array_", _assign_array_LockScreenInfo, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_LockScreenInfo), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_LockScreenInfo[] = {
+        { "alarm_icon", reinterpret_cast<getter>(LockScreenInfo_get_AlarmIcon), nullptr, nullptr, nullptr },
+        { "badges", reinterpret_cast<getter>(LockScreenInfo_get_Badges), nullptr, nullptr, nullptr },
+        { "detail_text", reinterpret_cast<getter>(LockScreenInfo_get_DetailText), nullptr, nullptr, nullptr },
+        { "lock_screen_image", reinterpret_cast<getter>(LockScreenInfo_get_LockScreenImage), nullptr, nullptr, nullptr },
+        { }
+    };
+
+    static PyType_Slot _type_slots_LockScreenInfo[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_LockScreenInfo) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LockScreenInfo) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_LockScreenInfo) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_LockScreenInfo) },
+        { },
+    };
+
+    static PyType_Spec type_spec_LockScreenInfo =
+    {
+        "winrt._winrt_windows_applicationmodel_lockscreen.LockScreenInfo",
+        sizeof(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenInfo),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_LockScreenInfo
+    };
+
+    // ----- LockScreenUnlockingDeferral class --------------------
+
+    static PyObject* _new_LockScreenUnlockingDeferral(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenUnlockingDeferral>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenUnlockingDeferral>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_LockScreenUnlockingDeferral(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenUnlockingDeferral* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* LockScreenUnlockingDeferral_Complete(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenUnlockingDeferral* self, PyObject* args) noexcept
+    {
+        auto arg_count = PyTuple_Size(args);
+
+        if (arg_count == 0)
+        {
+            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.LockScreen.LockScreenUnlockingDeferral", L"Complete", 0))
+            {
+                py::set_arg_count_version_error(0);
+                return nullptr;
+            }
+
+            try
+            {
+                self->obj.Complete();
+                Py_RETURN_NONE;
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_LockScreenUnlockingDeferral(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::LockScreen::LockScreenUnlockingDeferral>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_LockScreenUnlockingDeferral(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::ApplicationModel::LockScreen::LockScreenUnlockingDeferral>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_LockScreenUnlockingDeferral[] = {
+        { "complete", reinterpret_cast<PyCFunction>(LockScreenUnlockingDeferral_Complete), METH_VARARGS, nullptr },
+        { "_assign_array_", _assign_array_LockScreenUnlockingDeferral, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_LockScreenUnlockingDeferral), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_LockScreenUnlockingDeferral[] = {
+        { }
+    };
+
+    static PyType_Slot _type_slots_LockScreenUnlockingDeferral[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_LockScreenUnlockingDeferral) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LockScreenUnlockingDeferral) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_LockScreenUnlockingDeferral) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_LockScreenUnlockingDeferral) },
+        { },
+    };
+
+    static PyType_Spec type_spec_LockScreenUnlockingDeferral =
+    {
+        "winrt._winrt_windows_applicationmodel_lockscreen.LockScreenUnlockingDeferral",
+        sizeof(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenUnlockingDeferral),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_LockScreenUnlockingDeferral
+    };
+
+    // ----- LockScreenUnlockingEventArgs class --------------------
+
+    static PyObject* _new_LockScreenUnlockingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_LockScreenUnlockingEventArgs(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* LockScreenUnlockingEventArgs_GetDeferral(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs* self, PyObject* args) noexcept
+    {
+        auto arg_count = PyTuple_Size(args);
+
+        if (arg_count == 0)
+        {
+            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs", L"GetDeferral", 0))
+            {
+                py::set_arg_count_version_error(0);
+                return nullptr;
+            }
+
+            try
+            {
+                return py::convert(self->obj.GetDeferral());
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static PyObject* LockScreenUnlockingEventArgs_get_Deadline(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs", L"Deadline"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.Deadline());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_LockScreenUnlockingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_LockScreenUnlockingEventArgs(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::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_LockScreenUnlockingEventArgs[] = {
+        { "get_deferral", reinterpret_cast<PyCFunction>(LockScreenUnlockingEventArgs_GetDeferral), METH_VARARGS, nullptr },
+        { "_assign_array_", _assign_array_LockScreenUnlockingEventArgs, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_LockScreenUnlockingEventArgs), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_LockScreenUnlockingEventArgs[] = {
+        { "deadline", reinterpret_cast<getter>(LockScreenUnlockingEventArgs_get_Deadline), nullptr, nullptr, nullptr },
+        { }
+    };
+
+    static PyType_Slot _type_slots_LockScreenUnlockingEventArgs[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_LockScreenUnlockingEventArgs) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LockScreenUnlockingEventArgs) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_LockScreenUnlockingEventArgs) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_LockScreenUnlockingEventArgs) },
+        { },
+    };
+
+    static PyType_Spec type_spec_LockScreenUnlockingEventArgs =
+    {
+        "winrt._winrt_windows_applicationmodel_lockscreen.LockScreenUnlockingEventArgs",
+        sizeof(py::wrapper::Windows::ApplicationModel::LockScreen::LockScreenUnlockingEventArgs),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_LockScreenUnlockingEventArgs
+    };
+
+    // ----- Windows.ApplicationModel.LockScreen Initialization --------------------
+    PyDoc_STRVAR(module_doc, "Windows::ApplicationModel::LockScreen");
+
+
+    static PyModuleDef module_def
+        = {PyModuleDef_HEAD_INIT,
+           "_winrt_windows_applicationmodel_lockscreen",
+           module_doc,
+           0,
+           nullptr,
+           nullptr,
+           nullptr,
+           nullptr,
+           nullptr};
+
+} // py::cpp::Windows::ApplicationModel::LockScreen
+
+PyMODINIT_FUNC PyInit__winrt_windows_applicationmodel_lockscreen(void) noexcept
+{
+    using namespace py::cpp::Windows::ApplicationModel::LockScreen;
+
+    if (py::import_winrt_runtime() == -1)
+    {
+        return nullptr;
+    }
+
+    py::pyobj_handle module{PyModule_Create(&module_def)};
+
+    if (!module)
+    {
+        return nullptr;
+    }
+
+    auto object_type = py::get_object_type();
+    if (!object_type)
+    {
+        return nullptr;
+    }
+
+    py::pyobj_handle object_bases{PyTuple_Pack(1, object_type)};
+
+    if (!object_bases)
+    {
+        return nullptr;
+    }
+
+    py::pyobj_handle type_LockApplicationHost_Static{PyType_FromSpec(&type_spec_LockApplicationHost_Static)};
+    if (!type_LockApplicationHost_Static)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_LockApplicationHost, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_LockApplicationHost_Static.get())) == -1)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_LockScreenBadge, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_LockScreenInfo, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_LockScreenUnlockingDeferral, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_LockScreenUnlockingEventArgs, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
+
+    return module.detach();
+}

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/pyproject.toml

@@ -0,0 +1,43 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+[build-system]
+requires = ["setuptools", "setuptools-scm", "winrt-sdk"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "winrt-Windows.ApplicationModel.LockScreen"
+description = "Python projection of Windows Runtime (WinRT) APIs"
+readme = "README.md"
+license = { text = "MIT" }
+classifiers = [
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Intended Audience :: Developers",
+]
+dynamic = ["version", "dependencies", "optional-dependencies"]
+requires-python = ">=3.9,<3.13"
+
+[project.urls]
+# Homepage = "https://github.com/pywrint/pywrinrt"
+# Documentation = "https://readthedocs.org"
+Repository = "https://github.com/pywrint/pywrinrt"
+Changelog = "https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md"
+
+[tool.setuptools.dynamic]
+version = { file = "pywinrt-version.txt" }
+dependencies = { file = "requirements.txt" }
+optional-dependencies.all = { file = "all-requirements.txt" }
+
+[tool.cibuildwheel]
+# use local winrt-sdk build dependency
+environment = { PYTHONPATH="../winrt-sdk/src" }
+# don't install winrt-sdk from PyPI
+build-frontend = { name = "build", args = ["--skip-dependency-check", "--no-isolation"] }
+# don't build for PyPy
+skip = "pp*"
+# suppress warnings about ARM64 testing
+test-skip = "*-win_arm64"
+
+[tool.cibuildwheel.windows]
+archs = ["x86", "AMD64", "ARM64"]

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/pywinrt-version.txt

@@ -0,0 +1 @@
+2.0.0-beta.1

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/requirements.txt

@@ -0,0 +1,3 @@
+# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+
+winrt-runtime==2.0.0-beta.1

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/setup.py

@@ -0,0 +1,17 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+from setuptools import Extension, setup
+from winrt_sdk import get_include_dirs
+
+setup(
+    ext_modules=[
+        Extension(
+            "winrt._winrt_windows_applicationmodel_lockscreen",
+            sources=["py.Windows.ApplicationModel.LockScreen.cpp"],
+            include_dirs=get_include_dirs(),
+            extra_compile_args=["/std:c++20", "/permissive-"],
+            libraries=["windowsapp"],
+        )
+    ],
+    package_data={"winrt": ["*.pyi"]},
+)

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/winrt/_winrt_windows_applicationmodel_lockscreen.pyi

@@ -0,0 +1,72 @@
+# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+
+import datetime
+import sys
+import types
+import typing
+import uuid as _uuid
+from builtins import property as _property
+
+import winrt._winrt
+import winrt.system
+import winrt.windows.foundation
+import winrt.windows.foundation.collections
+import winrt.windows.storage.streams
+
+Self = typing.TypeVar('Self')
+
+class LockApplicationHost_Static(type):
+    def get_for_current_view(cls) -> typing.Optional[LockApplicationHost]: ...
+
+class LockApplicationHost(winrt.system.Object, metaclass=LockApplicationHost_Static):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> LockApplicationHost: ...
+    def request_unlock(self) -> None: ...
+    def add_unlocking(self, handler: winrt.windows.foundation.TypedEventHandler[LockApplicationHost, LockScreenUnlockingEventArgs], /) -> winrt.windows.foundation.EventRegistrationToken: ...
+    def remove_unlocking(self, token: winrt.windows.foundation.EventRegistrationToken, /) -> None: ...
+
+class LockScreenBadge(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> LockScreenBadge: ...
+    def launch_app(self) -> None: ...
+    @_property
+    def automation_name(self) -> str: ...
+    @_property
+    def glyph(self) -> typing.Optional[winrt.windows.storage.streams.IRandomAccessStream]: ...
+    @_property
+    def logo(self) -> typing.Optional[winrt.windows.storage.streams.IRandomAccessStream]: ...
+    @_property
+    def number(self) -> typing.Optional[typing.Optional[winrt.system.UInt32]]: ...
+
+class LockScreenInfo(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> LockScreenInfo: ...
+    def add_alarm_icon_changed(self, handler: winrt.windows.foundation.TypedEventHandler[LockScreenInfo, winrt.system.Object], /) -> winrt.windows.foundation.EventRegistrationToken: ...
+    def remove_alarm_icon_changed(self, token: winrt.windows.foundation.EventRegistrationToken, /) -> None: ...
+    def add_badges_changed(self, handler: winrt.windows.foundation.TypedEventHandler[LockScreenInfo, winrt.system.Object], /) -> winrt.windows.foundation.EventRegistrationToken: ...
+    def remove_badges_changed(self, token: winrt.windows.foundation.EventRegistrationToken, /) -> None: ...
+    def add_detail_text_changed(self, handler: winrt.windows.foundation.TypedEventHandler[LockScreenInfo, winrt.system.Object], /) -> winrt.windows.foundation.EventRegistrationToken: ...
+    def remove_detail_text_changed(self, token: winrt.windows.foundation.EventRegistrationToken, /) -> None: ...
+    def add_lock_screen_image_changed(self, handler: winrt.windows.foundation.TypedEventHandler[LockScreenInfo, winrt.system.Object], /) -> winrt.windows.foundation.EventRegistrationToken: ...
+    def remove_lock_screen_image_changed(self, token: winrt.windows.foundation.EventRegistrationToken, /) -> None: ...
+    @_property
+    def alarm_icon(self) -> typing.Optional[winrt.windows.storage.streams.IRandomAccessStream]: ...
+    @_property
+    def badges(self) -> typing.Optional[winrt.windows.foundation.collections.IVectorView[LockScreenBadge]]: ...
+    @_property
+    def detail_text(self) -> typing.Optional[winrt.windows.foundation.collections.IVectorView[str]]: ...
+    @_property
+    def lock_screen_image(self) -> typing.Optional[winrt.windows.storage.streams.IRandomAccessStream]: ...
+
+class LockScreenUnlockingDeferral(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> LockScreenUnlockingDeferral: ...
+    def complete(self) -> None: ...
+
+class LockScreenUnlockingEventArgs(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> LockScreenUnlockingEventArgs: ...
+    def get_deferral(self) -> typing.Optional[LockScreenUnlockingDeferral]: ...
+    @_property
+    def deadline(self) -> datetime.datetime: ...
+

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/winrt/windows/applicationmodel/lockscreen/__init__.py

@@ -0,0 +1,18 @@
+# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+
+import winrt.system
+from winrt import _winrt_windows_applicationmodel_lockscreen
+
+__all__ = [
+    "LockApplicationHost",
+    "LockScreenBadge",
+    "LockScreenInfo",
+    "LockScreenUnlockingDeferral",
+    "LockScreenUnlockingEventArgs",
+]
+
+LockApplicationHost = _winrt_windows_applicationmodel_lockscreen.LockApplicationHost
+LockScreenBadge = _winrt_windows_applicationmodel_lockscreen.LockScreenBadge
+LockScreenInfo = _winrt_windows_applicationmodel_lockscreen.LockScreenInfo
+LockScreenUnlockingDeferral = _winrt_windows_applicationmodel_lockscreen.LockScreenUnlockingDeferral
+LockScreenUnlockingEventArgs = _winrt_windows_applicationmodel_lockscreen.LockScreenUnlockingEventArgs

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/winrt_Windows.ApplicationModel.LockScreen.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: winrt-Windows.ApplicationModel.LockScreen
+Version: 2.0.0b1
+Summary: Python projection of Windows Runtime (WinRT) APIs
+License: MIT
+Project-URL: Repository, https://github.com/pywrint/pywrinrt
+Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Intended Audience :: Developers
+Requires-Python: <3.13,>=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: all
+
+<!-- warning: Please don't edit this file. It was automatically generated. -->
+
+# winrt-Windows.ApplicationModel.LockScreen
+
+Windows Runtime (WinRT) APIs for for the `Windows.ApplicationModel.LockScreen` namespace.
+
+This package provides the `winrt.windows.applicationmodel.lockscreen` module.

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/winrt_Windows.ApplicationModel.LockScreen.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+all-requirements.txt
+py.Windows.ApplicationModel.LockScreen.cpp
+pyproject.toml
+pywinrt-version.txt
+requirements.txt
+setup.py
+winrt/_winrt_windows_applicationmodel_lockscreen.pyi
+winrt/windows/applicationmodel/lockscreen/__init__.py
+winrt_Windows.ApplicationModel.LockScreen.egg-info/PKG-INFO
+winrt_Windows.ApplicationModel.LockScreen.egg-info/SOURCES.txt
+winrt_Windows.ApplicationModel.LockScreen.egg-info/dependency_links.txt
+winrt_Windows.ApplicationModel.LockScreen.egg-info/requires.txt
+winrt_Windows.ApplicationModel.LockScreen.egg-info/top_level.txt

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/winrt_Windows.ApplicationModel.LockScreen.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/winrt_Windows.ApplicationModel.LockScreen.egg-info/requires.txt

@@ -0,0 +1,6 @@
+winrt-runtime==2.0.0-beta.1
+
+[all]
+winrt-Windows.Foundation[all]==2.0.0-beta.1
+winrt-Windows.Foundation.Collections[all]==2.0.0-beta.1
+winrt-Windows.Storage.Streams[all]==2.0.0-beta.1

winrt-Windows.ApplicationModel.LockScreen-2.0.0b1/winrt_Windows.ApplicationModel.LockScreen.egg-info/top_level.txt

@@ -0,0 +1 @@
+winrt