winrt-Windows.Storage.Provider 2.0.0b1__tar.gz → 2.0.1__tar.gz

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: winrt-Windows.Storage.Provider
-Version: 2.0.0b1
+Version: 2.0.1
 Summary: Python projection of Windows Runtime (WinRT) APIs
 License: MIT
-Project-URL: Repository, https://github.com/pywrint/pywrinrt
+Project-URL: Documentation, https://pywinrt.readthedocs.io
+Project-URL: Repository, https://github.com/pywinrt/pywinrt
 Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
@@ -11,7 +12,13 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Intended Audience :: Developers
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: winrt-runtime==2.0.1
 Provides-Extra: all
+Requires-Dist: winrt-Windows.Foundation[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.Foundation.Collections[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.Storage[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.Storage.Streams[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.UI[all]==2.0.1; extra == "all"
 
 <!-- warning: Please don't edit this file. It was automatically generated. -->
 

winrt_windows_storage_provider-2.0.1/all-requirements.txt

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

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/py.Windows.Storage.Provider.cpp

@@ -1,4 +1,4 @@
-// WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+// WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.1
 
 #include "py.Windows.Storage.Provider.h"
 
@@ -1925,6 +1925,509 @@ namespace py::cpp::Windows::Storage::Provider
         _type_slots_StorageProviderItemPropertyDefinition
     };
 
+    // ----- StorageProviderKnownFolderEntry class --------------------
+
+    static PyObject* _new_StorageProviderKnownFolderEntry(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
+    {
+        if (kwds != nullptr)
+        {
+            py::set_invalid_kwd_args_error();
+            return nullptr;
+        }
+
+        auto arg_count = PyTuple_Size(args);
+        if (arg_count == 0)
+        {
+            try
+            {
+                winrt::Windows::Storage::Provider::StorageProviderKnownFolderEntry instance{  };
+                return py::wrap(instance, type);
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static void _dealloc_StorageProviderKnownFolderEntry(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderEntry* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* StorageProviderKnownFolderEntry_get_Status(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderEntry* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderEntry", L"Status"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.Status());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static int StorageProviderKnownFolderEntry_put_Status(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderEntry* self, PyObject* arg, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderEntry", L"Status"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return -1;
+        }
+
+        if (arg == nullptr)
+        {
+            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
+            return -1;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::Windows::Storage::Provider::StorageProviderKnownFolderSyncStatus>(arg);
+
+            self->obj.Status(param0);
+            return 0;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return -1;
+        }
+    }
+
+    static PyObject* StorageProviderKnownFolderEntry_get_KnownFolderId(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderEntry* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderEntry", L"KnownFolderId"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.KnownFolderId());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static int StorageProviderKnownFolderEntry_put_KnownFolderId(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderEntry* self, PyObject* arg, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderEntry", L"KnownFolderId"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return -1;
+        }
+
+        if (arg == nullptr)
+        {
+            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
+            return -1;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::guid>(arg);
+
+            self->obj.KnownFolderId(param0);
+            return 0;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return -1;
+        }
+    }
+
+    static PyObject* _assign_array_StorageProviderKnownFolderEntry(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::Storage::Provider::StorageProviderKnownFolderEntry>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_StorageProviderKnownFolderEntry(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::Storage::Provider::StorageProviderKnownFolderEntry>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_StorageProviderKnownFolderEntry[] = {
+        { "_assign_array_", _assign_array_StorageProviderKnownFolderEntry, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_StorageProviderKnownFolderEntry), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_StorageProviderKnownFolderEntry[] = {
+        { "status", reinterpret_cast<getter>(StorageProviderKnownFolderEntry_get_Status), reinterpret_cast<setter>(StorageProviderKnownFolderEntry_put_Status), nullptr, nullptr },
+        { "known_folder_id", reinterpret_cast<getter>(StorageProviderKnownFolderEntry_get_KnownFolderId), reinterpret_cast<setter>(StorageProviderKnownFolderEntry_put_KnownFolderId), nullptr, nullptr },
+        { }
+    };
+
+    static PyType_Slot _type_slots_StorageProviderKnownFolderEntry[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_StorageProviderKnownFolderEntry) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_StorageProviderKnownFolderEntry) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_StorageProviderKnownFolderEntry) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_StorageProviderKnownFolderEntry) },
+        { },
+    };
+
+    static PyType_Spec type_spec_StorageProviderKnownFolderEntry =
+    {
+        "winrt._winrt_windows_storage_provider.StorageProviderKnownFolderEntry",
+        sizeof(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderEntry),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_StorageProviderKnownFolderEntry
+    };
+
+    // ----- StorageProviderKnownFolderSyncInfo class --------------------
+
+    static PyObject* _new_StorageProviderKnownFolderSyncInfo(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
+    {
+        if (kwds != nullptr)
+        {
+            py::set_invalid_kwd_args_error();
+            return nullptr;
+        }
+
+        auto arg_count = PyTuple_Size(args);
+        if (arg_count == 0)
+        {
+            try
+            {
+                winrt::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo instance{  };
+                return py::wrap(instance, type);
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static void _dealloc_StorageProviderKnownFolderSyncInfo(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* StorageProviderKnownFolderSyncInfo_get_SyncRequested(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderSyncInfo", L"SyncRequested"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.SyncRequested());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static int StorageProviderKnownFolderSyncInfo_put_SyncRequested(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo* self, PyObject* arg, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderSyncInfo", L"SyncRequested"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return -1;
+        }
+
+        if (arg == nullptr)
+        {
+            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
+            return -1;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestedHandler>(arg);
+
+            self->obj.SyncRequested(param0);
+            return 0;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return -1;
+        }
+    }
+
+    static PyObject* StorageProviderKnownFolderSyncInfo_get_ProviderDisplayName(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderSyncInfo", L"ProviderDisplayName"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.ProviderDisplayName());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static int StorageProviderKnownFolderSyncInfo_put_ProviderDisplayName(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo* self, PyObject* arg, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderSyncInfo", L"ProviderDisplayName"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return -1;
+        }
+
+        if (arg == nullptr)
+        {
+            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
+            return -1;
+        }
+
+        try
+        {
+            auto param0 = py::convert_to<winrt::hstring>(arg);
+
+            self->obj.ProviderDisplayName(param0);
+            return 0;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return -1;
+        }
+    }
+
+    static PyObject* StorageProviderKnownFolderSyncInfo_get_KnownFolderEntries(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderSyncInfo", L"KnownFolderEntries"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.KnownFolderEntries());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_StorageProviderKnownFolderSyncInfo(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_StorageProviderKnownFolderSyncInfo(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::Storage::Provider::StorageProviderKnownFolderSyncInfo>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_StorageProviderKnownFolderSyncInfo[] = {
+        { "_assign_array_", _assign_array_StorageProviderKnownFolderSyncInfo, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_StorageProviderKnownFolderSyncInfo), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_StorageProviderKnownFolderSyncInfo[] = {
+        { "sync_requested", reinterpret_cast<getter>(StorageProviderKnownFolderSyncInfo_get_SyncRequested), reinterpret_cast<setter>(StorageProviderKnownFolderSyncInfo_put_SyncRequested), nullptr, nullptr },
+        { "provider_display_name", reinterpret_cast<getter>(StorageProviderKnownFolderSyncInfo_get_ProviderDisplayName), reinterpret_cast<setter>(StorageProviderKnownFolderSyncInfo_put_ProviderDisplayName), nullptr, nullptr },
+        { "known_folder_entries", reinterpret_cast<getter>(StorageProviderKnownFolderSyncInfo_get_KnownFolderEntries), nullptr, nullptr, nullptr },
+        { }
+    };
+
+    static PyType_Slot _type_slots_StorageProviderKnownFolderSyncInfo[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_StorageProviderKnownFolderSyncInfo) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_StorageProviderKnownFolderSyncInfo) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_StorageProviderKnownFolderSyncInfo) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_StorageProviderKnownFolderSyncInfo) },
+        { },
+    };
+
+    static PyType_Spec type_spec_StorageProviderKnownFolderSyncInfo =
+    {
+        "winrt._winrt_windows_storage_provider.StorageProviderKnownFolderSyncInfo",
+        sizeof(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncInfo),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_StorageProviderKnownFolderSyncInfo
+    };
+
+    // ----- StorageProviderKnownFolderSyncRequestArgs class --------------------
+
+    static PyObject* _new_StorageProviderKnownFolderSyncRequestArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_StorageProviderKnownFolderSyncRequestArgs(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* StorageProviderKnownFolderSyncRequestArgs_get_KnownFolders(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderSyncRequestArgs", L"KnownFolders"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.KnownFolders());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* StorageProviderKnownFolderSyncRequestArgs_get_Source(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs* self, void* /*unused*/) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Storage.Provider.StorageProviderKnownFolderSyncRequestArgs", L"Source"))
+        {
+            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
+            return nullptr;
+        }
+
+        try
+        {
+            return py::convert(self->obj.Source());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_StorageProviderKnownFolderSyncRequestArgs(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_StorageProviderKnownFolderSyncRequestArgs(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::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_StorageProviderKnownFolderSyncRequestArgs[] = {
+        { "_assign_array_", _assign_array_StorageProviderKnownFolderSyncRequestArgs, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_StorageProviderKnownFolderSyncRequestArgs), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_StorageProviderKnownFolderSyncRequestArgs[] = {
+        { "known_folders", reinterpret_cast<getter>(StorageProviderKnownFolderSyncRequestArgs_get_KnownFolders), nullptr, nullptr, nullptr },
+        { "source", reinterpret_cast<getter>(StorageProviderKnownFolderSyncRequestArgs_get_Source), nullptr, nullptr, nullptr },
+        { }
+    };
+
+    static PyType_Slot _type_slots_StorageProviderKnownFolderSyncRequestArgs[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_StorageProviderKnownFolderSyncRequestArgs) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_StorageProviderKnownFolderSyncRequestArgs) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_StorageProviderKnownFolderSyncRequestArgs) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_StorageProviderKnownFolderSyncRequestArgs) },
+        { },
+    };
+
+    static PyType_Spec type_spec_StorageProviderKnownFolderSyncRequestArgs =
+    {
+        "winrt._winrt_windows_storage_provider.StorageProviderKnownFolderSyncRequestArgs",
+        sizeof(py::wrapper::Windows::Storage::Provider::StorageProviderKnownFolderSyncRequestArgs),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_StorageProviderKnownFolderSyncRequestArgs
+    };
+
     // ----- StorageProviderMoreInfoUI class --------------------
 
     static PyObject* _new_StorageProviderMoreInfoUI(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
@@ -4119,6 +4622,249 @@ namespace py::cpp::Windows::Storage::Provider
         _type_slots_IStorageProviderItemPropertySource
     };
 
+    // ----- IStorageProviderKnownFolderSyncInfoSource interface --------------------
+
+    static PyObject* _new_IStorageProviderKnownFolderSyncInfoSource(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_IStorageProviderKnownFolderSyncInfoSource(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* IStorageProviderKnownFolderSyncInfoSource_GetKnownFolderSyncInfo(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource* self, PyObject* args) noexcept
+    {
+        auto arg_count = PyTuple_Size(args);
+
+        if (arg_count == 0)
+        {
+            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Storage.Provider.IStorageProviderKnownFolderSyncInfoSource", L"GetKnownFolderSyncInfo", 0))
+            {
+                py::set_arg_count_version_error(0);
+                return nullptr;
+            }
+
+            try
+            {
+                return py::convert(self->obj.GetKnownFolderSyncInfo());
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static PyObject* IStorageProviderKnownFolderSyncInfoSource_add_KnownFolderSyncInfoChanged(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Storage.Provider.IStorageProviderKnownFolderSyncInfoSource", L"KnownFolderSyncInfoChanged"))
+        {
+            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::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource, winrt::Windows::Foundation::IInspectable>>(arg);
+
+            return py::convert(self->obj.KnownFolderSyncInfoChanged(param0));
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* IStorageProviderKnownFolderSyncInfoSource_remove_KnownFolderSyncInfoChanged(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource* self, PyObject* arg) noexcept
+    {
+        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Storage.Provider.IStorageProviderKnownFolderSyncInfoSource", L"KnownFolderSyncInfoChanged"))
+        {
+            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.KnownFolderSyncInfoChanged(param0);
+            Py_RETURN_NONE;
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_IStorageProviderKnownFolderSyncInfoSource(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_IStorageProviderKnownFolderSyncInfoSource(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::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_IStorageProviderKnownFolderSyncInfoSource[] = {
+        { "get_known_folder_sync_info", reinterpret_cast<PyCFunction>(IStorageProviderKnownFolderSyncInfoSource_GetKnownFolderSyncInfo), METH_VARARGS, nullptr },
+        { "add_known_folder_sync_info_changed", reinterpret_cast<PyCFunction>(IStorageProviderKnownFolderSyncInfoSource_add_KnownFolderSyncInfoChanged), METH_O, nullptr },
+        { "remove_known_folder_sync_info_changed", reinterpret_cast<PyCFunction>(IStorageProviderKnownFolderSyncInfoSource_remove_KnownFolderSyncInfoChanged), METH_O, nullptr },
+        { "_assign_array_", _assign_array_IStorageProviderKnownFolderSyncInfoSource, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_IStorageProviderKnownFolderSyncInfoSource), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_IStorageProviderKnownFolderSyncInfoSource[] = {
+        { }
+    };
+
+    static PyType_Slot _type_slots_IStorageProviderKnownFolderSyncInfoSource[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_IStorageProviderKnownFolderSyncInfoSource) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IStorageProviderKnownFolderSyncInfoSource) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_IStorageProviderKnownFolderSyncInfoSource) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_IStorageProviderKnownFolderSyncInfoSource) },
+        { },
+    };
+
+    static PyType_Spec type_spec_IStorageProviderKnownFolderSyncInfoSource =
+    {
+        "winrt._winrt_windows_storage_provider.IStorageProviderKnownFolderSyncInfoSource",
+        sizeof(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSource),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_IStorageProviderKnownFolderSyncInfoSource
+    };
+
+    // ----- IStorageProviderKnownFolderSyncInfoSourceFactory interface --------------------
+
+    static PyObject* _new_IStorageProviderKnownFolderSyncInfoSourceFactory(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
+    {
+        static_assert(py::py_type<winrt::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSourceFactory>::type_name);
+        py::set_invalid_activation_error(py::py_type<winrt::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSourceFactory>::type_name);
+        return nullptr;
+    }
+
+    static void _dealloc_IStorageProviderKnownFolderSyncInfoSourceFactory(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSourceFactory* self) noexcept
+    {
+        auto tp = Py_TYPE(self);
+        std::destroy_at(&self->obj);
+        tp->tp_free(self);
+        Py_DECREF(tp);
+    }
+
+    static PyObject* IStorageProviderKnownFolderSyncInfoSourceFactory_GetKnownFolderSyncInfoSource(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSourceFactory* self, PyObject* args) noexcept
+    {
+        auto arg_count = PyTuple_Size(args);
+
+        if (arg_count == 0)
+        {
+            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Storage.Provider.IStorageProviderKnownFolderSyncInfoSourceFactory", L"GetKnownFolderSyncInfoSource", 0))
+            {
+                py::set_arg_count_version_error(0);
+                return nullptr;
+            }
+
+            try
+            {
+                return py::convert(self->obj.GetKnownFolderSyncInfoSource());
+            }
+            catch (...)
+            {
+                py::to_PyErr();
+                return nullptr;
+            }
+        }
+        else
+        {
+            py::set_invalid_arg_count_error(arg_count);
+            return nullptr;
+        }
+    }
+
+    static PyObject* _assign_array_IStorageProviderKnownFolderSyncInfoSourceFactory(PyObject* /*unused*/, PyObject* arg) noexcept
+    {
+        auto array = std::make_unique<py::ComArray<winrt::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSourceFactory>>();
+        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
+        {
+            return nullptr;
+        }
+        Py_RETURN_NONE;
+    }
+
+    static PyObject* _from_IStorageProviderKnownFolderSyncInfoSourceFactory(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::Storage::Provider::IStorageProviderKnownFolderSyncInfoSourceFactory>());
+        }
+        catch (...)
+        {
+            py::to_PyErr();
+            return nullptr;
+        }
+    }
+
+    static PyMethodDef _methods_IStorageProviderKnownFolderSyncInfoSourceFactory[] = {
+        { "get_known_folder_sync_info_source", reinterpret_cast<PyCFunction>(IStorageProviderKnownFolderSyncInfoSourceFactory_GetKnownFolderSyncInfoSource), METH_VARARGS, nullptr },
+        { "_assign_array_", _assign_array_IStorageProviderKnownFolderSyncInfoSourceFactory, METH_O | METH_STATIC, nullptr },
+        { "_from", reinterpret_cast<PyCFunction>(_from_IStorageProviderKnownFolderSyncInfoSourceFactory), METH_O | METH_STATIC, nullptr },
+        { }
+    };
+
+    static PyGetSetDef _getset_IStorageProviderKnownFolderSyncInfoSourceFactory[] = {
+        { }
+    };
+
+    static PyType_Slot _type_slots_IStorageProviderKnownFolderSyncInfoSourceFactory[] = 
+    {
+        { Py_tp_new, reinterpret_cast<void*>(_new_IStorageProviderKnownFolderSyncInfoSourceFactory) },
+        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IStorageProviderKnownFolderSyncInfoSourceFactory) },
+        { Py_tp_methods, reinterpret_cast<void*>(_methods_IStorageProviderKnownFolderSyncInfoSourceFactory) },
+        { Py_tp_getset, reinterpret_cast<void*>(_getset_IStorageProviderKnownFolderSyncInfoSourceFactory) },
+        { },
+    };
+
+    static PyType_Spec type_spec_IStorageProviderKnownFolderSyncInfoSourceFactory =
+    {
+        "winrt._winrt_windows_storage_provider.IStorageProviderKnownFolderSyncInfoSourceFactory",
+        sizeof(py::wrapper::Windows::Storage::Provider::IStorageProviderKnownFolderSyncInfoSourceFactory),
+        0,
+        Py_TPFLAGS_DEFAULT,
+        _type_slots_IStorageProviderKnownFolderSyncInfoSourceFactory
+    };
+
     // ----- IStorageProviderPropertyCapabilities interface --------------------
 
     static PyObject* _new_IStorageProviderPropertyCapabilities(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
@@ -4895,6 +5641,21 @@ PyMODINIT_FUNC PyInit__winrt_windows_storage_provider(void) noexcept
         return nullptr;
     }
 
+    if (py::register_python_type(module.get(), &type_spec_StorageProviderKnownFolderEntry, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_StorageProviderKnownFolderSyncInfo, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_StorageProviderKnownFolderSyncRequestArgs, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
     if (py::register_python_type(module.get(), &type_spec_StorageProviderMoreInfoUI, object_bases.get(), nullptr) == -1)
     {
         return nullptr;
@@ -4931,6 +5692,16 @@ PyMODINIT_FUNC PyInit__winrt_windows_storage_provider(void) noexcept
         return nullptr;
     }
 
+    if (py::register_python_type(module.get(), &type_spec_IStorageProviderKnownFolderSyncInfoSource, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
+    if (py::register_python_type(module.get(), &type_spec_IStorageProviderKnownFolderSyncInfoSourceFactory, object_bases.get(), nullptr) == -1)
+    {
+        return nullptr;
+    }
+
     if (py::register_python_type(module.get(), &type_spec_IStorageProviderPropertyCapabilities, object_bases.get(), nullptr) == -1)
     {
         return nullptr;

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/pyproject.toml

@@ -1,7 +1,7 @@
 # WARNING: Please don't edit this file. It was automatically generated.
 
 [build-system]
-requires = ["setuptools", "setuptools-scm", "winrt-sdk"]
+requires = ["setuptools", "winrt-sdk"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -19,9 +19,9 @@ 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"
+# Homepage = "https://github.com/pywinrt/pywinrt"
+Documentation = "https://pywinrt.readthedocs.io"
+Repository = "https://github.com/pywinrt/pywinrt"
 Changelog = "https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md"
 
 [tool.setuptools.dynamic]
@@ -29,6 +29,9 @@ version = { file = "pywinrt-version.txt" }
 dependencies = { file = "requirements.txt" }
 optional-dependencies.all = { file = "all-requirements.txt" }
 
+[tool.setuptools.package-data]
+"*" = ["*.pyi", "py.typed"]
+
 [tool.cibuildwheel]
 # use local winrt-sdk build dependency
 environment = { PYTHONPATH="../winrt-sdk/src" }

winrt_windows_storage_provider-2.0.1/pywinrt-version.txt

@@ -0,0 +1 @@
+2.0.1

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/requirements.txt

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

winrt_windows_storage_provider-2.0.1/setup.py

@@ -0,0 +1,31 @@
+# WARNING: Please don't edit this file. It was automatically generated.
+
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+from winrt_sdk import get_include_dirs
+
+
+class build_ext_ex(build_ext):
+    def build_extension(self, ext):
+        if self.compiler.compiler_type == "msvc":
+            ext.extra_compile_args = ["/std:c++20", "/permissive-"]
+        elif self.compiler.compiler_type == "mingw32":
+            ext.extra_compile_args = ["-std=c++20", "-D_WIN32_WINNT=_WIN32_WINNT_WIN10"]
+            ext.extra_link_args = ["-loleaut32"]
+        else:
+            raise ValueError(f"Unsupported compiler: {self.compiler.compiler_type}")
+
+        build_ext.build_extension(self, ext)
+
+
+setup(
+    cmdclass = {'build_ext': build_ext_ex},
+    ext_modules=[
+        Extension(
+            "winrt._winrt_windows_storage_provider",
+            sources=["py.Windows.Storage.Provider.cpp"],
+            include_dirs=get_include_dirs(),
+            libraries=["windowsapp"],
+        )
+    ],
+)

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/winrt/_winrt_windows_storage_provider.pyi

@@ -1,4 +1,4 @@
-# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.1
 
 import datetime
 import sys
@@ -15,17 +15,21 @@ import winrt.windows.storage
 import winrt.windows.storage.streams
 import winrt.windows.ui
 
-from winrt.windows.storage.provider import CachedFileOptions, CachedFileTarget, FileUpdateStatus, ReadActivationMode, StorageProviderHardlinkPolicy, StorageProviderHydrationPolicy, StorageProviderHydrationPolicyModifier, StorageProviderInSyncPolicy, StorageProviderPopulationPolicy, StorageProviderProtectionMode, StorageProviderState, StorageProviderUICommandState, StorageProviderUriSourceStatus, UIStatus, WriteActivationMode
+from winrt.windows.storage.provider import CachedFileOptions, CachedFileTarget, FileUpdateStatus, ReadActivationMode, StorageProviderHardlinkPolicy, StorageProviderHydrationPolicy, StorageProviderHydrationPolicyModifier, StorageProviderInSyncPolicy, StorageProviderKnownFolderSyncStatus, StorageProviderPopulationPolicy, StorageProviderProtectionMode, StorageProviderState, StorageProviderUICommandState, StorageProviderUriSourceStatus, UIStatus, WriteActivationMode
+from winrt.windows.storage.provider import StorageProviderKnownFolderSyncRequestedHandler
 
 Self = typing.TypeVar('Self')
 
+@typing.final
 class CachedFileUpdater_Static(type):
     def set_update_information(cls, file: typing.Optional[winrt.windows.storage.IStorageFile], content_id: str, read_mode: ReadActivationMode, write_mode: WriteActivationMode, options: CachedFileOptions, /) -> None: ...
 
+@typing.final
 class CachedFileUpdater(winrt.system.Object, metaclass=CachedFileUpdater_Static):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> CachedFileUpdater: ...
 
+@typing.final
 class CachedFileUpdaterUI(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> CachedFileUpdaterUI: ...
@@ -45,6 +49,7 @@ class CachedFileUpdaterUI(winrt.system.Object):
     @_property
     def update_request(self) -> typing.Optional[FileUpdateRequest]: ...
 
+@typing.final
 class FileUpdateRequest(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> FileUpdateRequest: ...
@@ -63,17 +68,20 @@ class FileUpdateRequest(winrt.system.Object):
     @user_input_needed_message.setter
     def user_input_needed_message(self, value: str) -> None: ...
 
+@typing.final
 class FileUpdateRequestDeferral(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> FileUpdateRequestDeferral: ...
     def complete(self) -> None: ...
 
+@typing.final
 class FileUpdateRequestedEventArgs(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> FileUpdateRequestedEventArgs: ...
     @_property
     def request(self) -> typing.Optional[FileUpdateRequest]: ...
 
+@typing.final
 class StorageProviderFileTypeInfo(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderFileTypeInfo: ...
@@ -83,6 +91,7 @@ class StorageProviderFileTypeInfo(winrt.system.Object):
     @_property
     def icon_resource(self) -> str: ...
 
+@typing.final
 class StorageProviderGetContentInfoForPathResult(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderGetContentInfoForPathResult: ...
@@ -100,6 +109,7 @@ class StorageProviderGetContentInfoForPathResult(winrt.system.Object):
     @content_id.setter
     def content_id(self, value: str) -> None: ...
 
+@typing.final
 class StorageProviderGetPathForContentUriResult(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderGetPathForContentUriResult: ...
@@ -113,13 +123,16 @@ class StorageProviderGetPathForContentUriResult(winrt.system.Object):
     @path.setter
     def path(self, value: str) -> None: ...
 
+@typing.final
 class StorageProviderItemProperties_Static(type):
     def set_async(cls, item: typing.Optional[winrt.windows.storage.IStorageItem], item_properties: typing.Iterable[StorageProviderItemProperty], /) -> winrt.windows.foundation.IAsyncAction: ...
 
+@typing.final
 class StorageProviderItemProperties(winrt.system.Object, metaclass=StorageProviderItemProperties_Static):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderItemProperties: ...
 
+@typing.final
 class StorageProviderItemProperty(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderItemProperty: ...
@@ -137,6 +150,7 @@ class StorageProviderItemProperty(winrt.system.Object):
     @icon_resource.setter
     def icon_resource(self, value: str) -> None: ...
 
+@typing.final
 class StorageProviderItemPropertyDefinition(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderItemPropertyDefinition: ...
@@ -150,6 +164,46 @@ class StorageProviderItemPropertyDefinition(winrt.system.Object):
     @display_name_resource.setter
     def display_name_resource(self, value: str) -> None: ...
 
+@typing.final
+class StorageProviderKnownFolderEntry(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> StorageProviderKnownFolderEntry: ...
+    def __new__(cls: typing.Type[StorageProviderKnownFolderEntry]) -> StorageProviderKnownFolderEntry:...
+    @_property
+    def status(self) -> StorageProviderKnownFolderSyncStatus: ...
+    @status.setter
+    def status(self, value: StorageProviderKnownFolderSyncStatus) -> None: ...
+    @_property
+    def known_folder_id(self) -> _uuid.UUID: ...
+    @known_folder_id.setter
+    def known_folder_id(self, value: _uuid.UUID) -> None: ...
+
+@typing.final
+class StorageProviderKnownFolderSyncInfo(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> StorageProviderKnownFolderSyncInfo: ...
+    def __new__(cls: typing.Type[StorageProviderKnownFolderSyncInfo]) -> StorageProviderKnownFolderSyncInfo:...
+    @_property
+    def sync_requested(self) -> typing.Optional[StorageProviderKnownFolderSyncRequestedHandler]: ...
+    @sync_requested.setter
+    def sync_requested(self, value: typing.Optional[StorageProviderKnownFolderSyncRequestedHandler]) -> None: ...
+    @_property
+    def provider_display_name(self) -> str: ...
+    @provider_display_name.setter
+    def provider_display_name(self, value: str) -> None: ...
+    @_property
+    def known_folder_entries(self) -> typing.Optional[winrt.windows.foundation.collections.IVector[StorageProviderKnownFolderEntry]]: ...
+
+@typing.final
+class StorageProviderKnownFolderSyncRequestArgs(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> StorageProviderKnownFolderSyncRequestArgs: ...
+    @_property
+    def known_folders(self) -> typing.Optional[winrt.windows.foundation.collections.IVectorView[_uuid.UUID]]: ...
+    @_property
+    def source(self) -> typing.Optional[winrt.windows.storage.StorageFolder]: ...
+
+@typing.final
 class StorageProviderMoreInfoUI(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderMoreInfoUI: ...
@@ -163,6 +217,7 @@ class StorageProviderMoreInfoUI(winrt.system.Object):
     @command.setter
     def command(self, value: typing.Optional[IStorageProviderUICommand]) -> None: ...
 
+@typing.final
 class StorageProviderQuotaUI(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderQuotaUI: ...
@@ -184,6 +239,7 @@ class StorageProviderQuotaUI(winrt.system.Object):
     @quota_total_in_bytes.setter
     def quota_total_in_bytes(self, value: winrt.system.UInt64) -> None: ...
 
+@typing.final
 class StorageProviderStatusUI(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderStatusUI: ...
@@ -221,6 +277,7 @@ class StorageProviderStatusUI(winrt.system.Object):
     @more_info_u_i.setter
     def more_info_u_i(self, value: typing.Optional[StorageProviderMoreInfoUI]) -> None: ...
 
+@typing.final
 class StorageProviderSyncRootInfo(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderSyncRootInfo: ...
@@ -294,6 +351,7 @@ class StorageProviderSyncRootInfo(winrt.system.Object):
     @_property
     def fallback_file_type_info(self) -> typing.Optional[winrt.windows.foundation.collections.IVector[StorageProviderFileTypeInfo]]: ...
 
+@typing.final
 class StorageProviderSyncRootManager_Static(type):
     def get_current_sync_roots(cls) -> typing.Optional[winrt.windows.foundation.collections.IVectorView[StorageProviderSyncRootInfo]]: ...
     def get_sync_root_information_for_folder(cls, folder: typing.Optional[winrt.windows.storage.IStorageFolder], /) -> typing.Optional[StorageProviderSyncRootInfo]: ...
@@ -302,20 +360,38 @@ class StorageProviderSyncRootManager_Static(type):
     def register(cls, sync_root_information: typing.Optional[StorageProviderSyncRootInfo], /) -> None: ...
     def unregister(cls, id: str, /) -> None: ...
 
+@typing.final
 class StorageProviderSyncRootManager(winrt.system.Object, metaclass=StorageProviderSyncRootManager_Static):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> StorageProviderSyncRootManager: ...
 
+@typing.final
 class IStorageProviderItemPropertySource(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> IStorageProviderItemPropertySource: ...
     def get_item_properties(self, item_path: str, /) -> typing.Optional[winrt.windows.foundation.collections.IIterable[StorageProviderItemProperty]]: ...
 
+@typing.final
+class IStorageProviderKnownFolderSyncInfoSource(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> IStorageProviderKnownFolderSyncInfoSource: ...
+    def get_known_folder_sync_info(self) -> typing.Optional[StorageProviderKnownFolderSyncInfo]: ...
+    def add_known_folder_sync_info_changed(self, handler: winrt.windows.foundation.TypedEventHandler[IStorageProviderKnownFolderSyncInfoSource, winrt.system.Object], /) -> winrt.windows.foundation.EventRegistrationToken: ...
+    def remove_known_folder_sync_info_changed(self, token: winrt.windows.foundation.EventRegistrationToken, /) -> None: ...
+
+@typing.final
+class IStorageProviderKnownFolderSyncInfoSourceFactory(winrt.system.Object):
+    @staticmethod
+    def _from(obj: winrt.system.Object, /) -> IStorageProviderKnownFolderSyncInfoSourceFactory: ...
+    def get_known_folder_sync_info_source(self) -> typing.Optional[IStorageProviderKnownFolderSyncInfoSource]: ...
+
+@typing.final
 class IStorageProviderPropertyCapabilities(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> IStorageProviderPropertyCapabilities: ...
     def is_property_supported(self, property_canonical_name: str, /) -> bool: ...
 
+@typing.final
 class IStorageProviderStatusUISource(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> IStorageProviderStatusUISource: ...
@@ -323,11 +399,13 @@ class IStorageProviderStatusUISource(winrt.system.Object):
     def add_status_u_i_changed(self, handler: winrt.windows.foundation.TypedEventHandler[IStorageProviderStatusUISource, winrt.system.Object], /) -> winrt.windows.foundation.EventRegistrationToken: ...
     def remove_status_u_i_changed(self, token: winrt.windows.foundation.EventRegistrationToken, /) -> None: ...
 
+@typing.final
 class IStorageProviderStatusUISourceFactory(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> IStorageProviderStatusUISourceFactory: ...
     def get_status_u_i_source(self, sync_root_id: str, /) -> typing.Optional[IStorageProviderStatusUISource]: ...
 
+@typing.final
 class IStorageProviderUICommand(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> IStorageProviderUICommand: ...
@@ -341,6 +419,7 @@ class IStorageProviderUICommand(winrt.system.Object):
     @_property
     def state(self) -> StorageProviderUICommandState: ...
 
+@typing.final
 class IStorageProviderUriSource(winrt.system.Object):
     @staticmethod
     def _from(obj: winrt.system.Object, /) -> IStorageProviderUriSource: ...

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/winrt/windows/storage/provider/__init__.py

@@ -1,6 +1,8 @@
-# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.0-beta.1
+# WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.1
 
 import enum
+import typing
+import uuid as _uuid
 
 import winrt.system
 from winrt import _winrt_windows_storage_provider
@@ -14,6 +16,7 @@ __all__ = [
     "StorageProviderHydrationPolicy",
     "StorageProviderHydrationPolicyModifier",
     "StorageProviderInSyncPolicy",
+    "StorageProviderKnownFolderSyncStatus",
     "StorageProviderPopulationPolicy",
     "StorageProviderProtectionMode",
     "StorageProviderState",
@@ -32,17 +35,23 @@ __all__ = [
     "StorageProviderItemProperties",
     "StorageProviderItemProperty",
     "StorageProviderItemPropertyDefinition",
+    "StorageProviderKnownFolderEntry",
+    "StorageProviderKnownFolderSyncInfo",
+    "StorageProviderKnownFolderSyncRequestArgs",
     "StorageProviderMoreInfoUI",
     "StorageProviderQuotaUI",
     "StorageProviderStatusUI",
     "StorageProviderSyncRootInfo",
     "StorageProviderSyncRootManager",
     "IStorageProviderItemPropertySource",
+    "IStorageProviderKnownFolderSyncInfoSource",
+    "IStorageProviderKnownFolderSyncInfoSourceFactory",
     "IStorageProviderPropertyCapabilities",
     "IStorageProviderStatusUISource",
     "IStorageProviderStatusUISourceFactory",
     "IStorageProviderUICommand",
     "IStorageProviderUriSource",
+    "StorageProviderKnownFolderSyncRequestedHandler",
 ]
 
 class CachedFileOptions(enum.IntFlag):
@@ -98,6 +107,11 @@ class StorageProviderInSyncPolicy(enum.IntFlag):
     DIRECTORY_LAST_WRITE_TIME = 0x200
     PRESERVE_INSYNC_FOR_SYNC_ENGINE = 0x80000000
 
+class StorageProviderKnownFolderSyncStatus(enum.IntEnum):
+    AVAILABLE = 0
+    ENROLLING = 1
+    ENROLLED = 2
+
 class StorageProviderPopulationPolicy(enum.IntEnum):
     FULL = 1
     ALWAYS_FULL = 2
@@ -146,14 +160,20 @@ StorageProviderGetPathForContentUriResult = _winrt_windows_storage_provider.Stor
 StorageProviderItemProperties = _winrt_windows_storage_provider.StorageProviderItemProperties
 StorageProviderItemProperty = _winrt_windows_storage_provider.StorageProviderItemProperty
 StorageProviderItemPropertyDefinition = _winrt_windows_storage_provider.StorageProviderItemPropertyDefinition
+StorageProviderKnownFolderEntry = _winrt_windows_storage_provider.StorageProviderKnownFolderEntry
+StorageProviderKnownFolderSyncInfo = _winrt_windows_storage_provider.StorageProviderKnownFolderSyncInfo
+StorageProviderKnownFolderSyncRequestArgs = _winrt_windows_storage_provider.StorageProviderKnownFolderSyncRequestArgs
 StorageProviderMoreInfoUI = _winrt_windows_storage_provider.StorageProviderMoreInfoUI
 StorageProviderQuotaUI = _winrt_windows_storage_provider.StorageProviderQuotaUI
 StorageProviderStatusUI = _winrt_windows_storage_provider.StorageProviderStatusUI
 StorageProviderSyncRootInfo = _winrt_windows_storage_provider.StorageProviderSyncRootInfo
 StorageProviderSyncRootManager = _winrt_windows_storage_provider.StorageProviderSyncRootManager
 IStorageProviderItemPropertySource = _winrt_windows_storage_provider.IStorageProviderItemPropertySource
+IStorageProviderKnownFolderSyncInfoSource = _winrt_windows_storage_provider.IStorageProviderKnownFolderSyncInfoSource
+IStorageProviderKnownFolderSyncInfoSourceFactory = _winrt_windows_storage_provider.IStorageProviderKnownFolderSyncInfoSourceFactory
 IStorageProviderPropertyCapabilities = _winrt_windows_storage_provider.IStorageProviderPropertyCapabilities
 IStorageProviderStatusUISource = _winrt_windows_storage_provider.IStorageProviderStatusUISource
 IStorageProviderStatusUISourceFactory = _winrt_windows_storage_provider.IStorageProviderStatusUISourceFactory
 IStorageProviderUICommand = _winrt_windows_storage_provider.IStorageProviderUICommand
 IStorageProviderUriSource = _winrt_windows_storage_provider.IStorageProviderUriSource
+StorageProviderKnownFolderSyncRequestedHandler = typing.Callable[[typing.Optional[StorageProviderKnownFolderSyncRequestArgs]], None]

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/winrt_Windows.Storage.Provider.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: winrt-Windows.Storage.Provider
-Version: 2.0.0b1
+Version: 2.0.1
 Summary: Python projection of Windows Runtime (WinRT) APIs
 License: MIT
-Project-URL: Repository, https://github.com/pywrint/pywrinrt
+Project-URL: Documentation, https://pywinrt.readthedocs.io
+Project-URL: Repository, https://github.com/pywinrt/pywinrt
 Project-URL: Changelog, https://github.com/pywinrt/pywinrt/blob/main/CHANGELOG.md
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
@@ -11,7 +12,13 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Intended Audience :: Developers
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: winrt-runtime==2.0.1
 Provides-Extra: all
+Requires-Dist: winrt-Windows.Foundation[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.Foundation.Collections[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.Storage[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.Storage.Streams[all]==2.0.1; extra == "all"
+Requires-Dist: winrt-Windows.UI[all]==2.0.1; extra == "all"
 
 <!-- warning: Please don't edit this file. It was automatically generated. -->
 

{winrt-Windows.Storage.Provider-2.0.0b1 → winrt_windows_storage_provider-2.0.1}/winrt_Windows.Storage.Provider.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ requirements.txt
 setup.py
 winrt/_winrt_windows_storage_provider.pyi
 winrt/windows/storage/provider/__init__.py
+winrt/windows/storage/provider/py.typed
 winrt_Windows.Storage.Provider.egg-info/PKG-INFO
 winrt_Windows.Storage.Provider.egg-info/SOURCES.txt
 winrt_Windows.Storage.Provider.egg-info/dependency_links.txt

winrt_windows_storage_provider-2.0.1/winrt_Windows.Storage.Provider.egg-info/requires.txt

@@ -0,0 +1,8 @@
+winrt-runtime==2.0.1
+
+[all]
+winrt-Windows.Foundation[all]==2.0.1
+winrt-Windows.Foundation.Collections[all]==2.0.1
+winrt-Windows.Storage[all]==2.0.1
+winrt-Windows.Storage.Streams[all]==2.0.1
+winrt-Windows.UI[all]==2.0.1

winrt-Windows.Storage.Provider-2.0.0b1/all-requirements.txt

@@ -1,7 +0,0 @@
-# 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[all]==2.0.0-beta.1
-winrt-Windows.Storage.Streams[all]==2.0.0-beta.1
-winrt-Windows.UI[all]==2.0.0-beta.1

winrt-Windows.Storage.Provider-2.0.0b1/pywinrt-version.txt

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

winrt-Windows.Storage.Provider-2.0.0b1/setup.py

@@ -1,17 +0,0 @@
-# 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_storage_provider",
-            sources=["py.Windows.Storage.Provider.cpp"],
-            include_dirs=get_include_dirs(),
-            extra_compile_args=["/std:c++20", "/permissive-"],
-            libraries=["windowsapp"],
-        )
-    ],
-    package_data={"winrt": ["*.pyi"]},
-)

winrt-Windows.Storage.Provider-2.0.0b1/winrt_Windows.Storage.Provider.egg-info/requires.txt

@@ -1,8 +0,0 @@
-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[all]==2.0.0-beta.1
-winrt-Windows.Storage.Streams[all]==2.0.0-beta.1
-winrt-Windows.UI[all]==2.0.0-beta.1