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

#include "pybase.h"
#include "py.Windows.Storage.BulkAccess.h"

PyTypeObject* py::winrt_type<winrt::Windows::Storage::BulkAccess::FileInformation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Storage::BulkAccess::FileInformationFactory>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Storage::BulkAccess::FolderInformation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Storage::BulkAccess::IStorageItemInformation>::python_type;

namespace py::cpp::Windows::Storage::BulkAccess
{
    // ----- FileInformation class --------------------
    constexpr const char* const _type_name_FileInformation = "FileInformation";

    static PyObject* _new_FileInformation(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_FileInformation);
        return nullptr;
    }

    static void _dealloc_FileInformation(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* FileInformation_CopyAndReplaceAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFile>(args, 0);

                return py::convert(self->obj.CopyAndReplaceAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_CopyAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFolder>(args, 0);

                return py::convert(self->obj.CopyAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFolder>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);

                return py::convert(self->obj.CopyAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFolder>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Storage::NameCollisionOption>(args, 2);

                return py::convert(self->obj.CopyAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_DeleteAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.DeleteAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::StorageDeleteOption>(args, 0);

                return py::convert(self->obj.DeleteAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_GetBasicPropertiesAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetBasicPropertiesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_GetParentAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetParentAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_GetThumbnailAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 0);

                return py::convert(self->obj.GetThumbnailAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);

                return py::convert(self->obj.GetThumbnailAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailOptions>(args, 2);

                return py::convert(self->obj.GetThumbnailAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_IsEqual(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageItem>(args, 0);

                return py::convert(self->obj.IsEqual(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_IsOfType(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::StorageItemTypes>(args, 0);

                return py::convert(self->obj.IsOfType(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_MoveAndReplaceAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFile>(args, 0);

                return py::convert(self->obj.MoveAndReplaceAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_MoveAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFolder>(args, 0);

                return py::convert(self->obj.MoveAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFolder>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);

                return py::convert(self->obj.MoveAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFolder>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Storage::NameCollisionOption>(args, 2);

                return py::convert(self->obj.MoveAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_OpenAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileAccessMode>(args, 0);

                return py::convert(self->obj.OpenAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileAccessMode>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::StorageOpenOptions>(args, 1);

                return py::convert(self->obj.OpenAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_OpenReadAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.OpenReadAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_OpenSequentialReadAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.OpenSequentialReadAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_OpenTransactedWriteAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.OpenTransactedWriteAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::StorageOpenOptions>(args, 0);

                return py::convert(self->obj.OpenTransactedWriteAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_RenameAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.RenameAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::NameCollisionOption>(args, 1);

                return py::convert(self->obj.RenameAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_BasicProperties(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BasicProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_DocumentProperties(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DocumentProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_ImageProperties(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ImageProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_MusicProperties(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.MusicProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_Thumbnail(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Thumbnail());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_VideoProperties(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.VideoProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_ContentType(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ContentType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_FileType(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FileType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_IsAvailable(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsAvailable());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_Attributes(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_DateCreated(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DateCreated());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_Name(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_Path(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Path());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_DisplayName(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_DisplayType(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_FolderRelativeId(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FolderRelativeId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_Properties(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Properties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_get_Provider(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Provider());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_add_PropertiesUpdated(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Storage::BulkAccess::IStorageItemInformation, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PropertiesUpdated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_remove_PropertiesUpdated(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PropertiesUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_add_ThumbnailUpdated(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Storage::BulkAccess::IStorageItemInformation, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ThumbnailUpdated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FileInformation_remove_ThumbnailUpdated(py::wrapper::Windows::Storage::BulkAccess::FileInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ThumbnailUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_FileInformation(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::BulkAccess::FileInformation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FileInformation[] = {
        { "copy_and_replace_async", reinterpret_cast<PyCFunction>(FileInformation_CopyAndReplaceAsync), METH_VARARGS, nullptr },
        { "copy_async", reinterpret_cast<PyCFunction>(FileInformation_CopyAsync), METH_VARARGS, nullptr },
        { "delete_async", reinterpret_cast<PyCFunction>(FileInformation_DeleteAsync), METH_VARARGS, nullptr },
        { "get_basic_properties_async", reinterpret_cast<PyCFunction>(FileInformation_GetBasicPropertiesAsync), METH_VARARGS, nullptr },
        { "get_parent_async", reinterpret_cast<PyCFunction>(FileInformation_GetParentAsync), METH_VARARGS, nullptr },
        { "get_thumbnail_async", reinterpret_cast<PyCFunction>(FileInformation_GetThumbnailAsync), METH_VARARGS, nullptr },
        { "is_equal", reinterpret_cast<PyCFunction>(FileInformation_IsEqual), METH_VARARGS, nullptr },
        { "is_of_type", reinterpret_cast<PyCFunction>(FileInformation_IsOfType), METH_VARARGS, nullptr },
        { "move_and_replace_async", reinterpret_cast<PyCFunction>(FileInformation_MoveAndReplaceAsync), METH_VARARGS, nullptr },
        { "move_async", reinterpret_cast<PyCFunction>(FileInformation_MoveAsync), METH_VARARGS, nullptr },
        { "open_async", reinterpret_cast<PyCFunction>(FileInformation_OpenAsync), METH_VARARGS, nullptr },
        { "open_read_async", reinterpret_cast<PyCFunction>(FileInformation_OpenReadAsync), METH_VARARGS, nullptr },
        { "open_sequential_read_async", reinterpret_cast<PyCFunction>(FileInformation_OpenSequentialReadAsync), METH_VARARGS, nullptr },
        { "open_transacted_write_async", reinterpret_cast<PyCFunction>(FileInformation_OpenTransactedWriteAsync), METH_VARARGS, nullptr },
        { "rename_async", reinterpret_cast<PyCFunction>(FileInformation_RenameAsync), METH_VARARGS, nullptr },
        { "add_properties_updated", reinterpret_cast<PyCFunction>(FileInformation_add_PropertiesUpdated), METH_O, nullptr },
        { "remove_properties_updated", reinterpret_cast<PyCFunction>(FileInformation_remove_PropertiesUpdated), METH_O, nullptr },
        { "add_thumbnail_updated", reinterpret_cast<PyCFunction>(FileInformation_add_ThumbnailUpdated), METH_O, nullptr },
        { "remove_thumbnail_updated", reinterpret_cast<PyCFunction>(FileInformation_remove_ThumbnailUpdated), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FileInformation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FileInformation[] = {
        { "basic_properties", reinterpret_cast<getter>(FileInformation_get_BasicProperties), nullptr, nullptr, nullptr },
        { "document_properties", reinterpret_cast<getter>(FileInformation_get_DocumentProperties), nullptr, nullptr, nullptr },
        { "image_properties", reinterpret_cast<getter>(FileInformation_get_ImageProperties), nullptr, nullptr, nullptr },
        { "music_properties", reinterpret_cast<getter>(FileInformation_get_MusicProperties), nullptr, nullptr, nullptr },
        { "thumbnail", reinterpret_cast<getter>(FileInformation_get_Thumbnail), nullptr, nullptr, nullptr },
        { "video_properties", reinterpret_cast<getter>(FileInformation_get_VideoProperties), nullptr, nullptr, nullptr },
        { "content_type", reinterpret_cast<getter>(FileInformation_get_ContentType), nullptr, nullptr, nullptr },
        { "file_type", reinterpret_cast<getter>(FileInformation_get_FileType), nullptr, nullptr, nullptr },
        { "is_available", reinterpret_cast<getter>(FileInformation_get_IsAvailable), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(FileInformation_get_Attributes), nullptr, nullptr, nullptr },
        { "date_created", reinterpret_cast<getter>(FileInformation_get_DateCreated), nullptr, nullptr, nullptr },
        { "name", reinterpret_cast<getter>(FileInformation_get_Name), nullptr, nullptr, nullptr },
        { "path", reinterpret_cast<getter>(FileInformation_get_Path), nullptr, nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(FileInformation_get_DisplayName), nullptr, nullptr, nullptr },
        { "display_type", reinterpret_cast<getter>(FileInformation_get_DisplayType), nullptr, nullptr, nullptr },
        { "folder_relative_id", reinterpret_cast<getter>(FileInformation_get_FolderRelativeId), nullptr, nullptr, nullptr },
        { "properties", reinterpret_cast<getter>(FileInformation_get_Properties), nullptr, nullptr, nullptr },
        { "provider", reinterpret_cast<getter>(FileInformation_get_Provider), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_FileInformation[] = 
    {
        { Py_tp_new, _new_FileInformation },
        { Py_tp_dealloc, _dealloc_FileInformation },
        { Py_tp_methods, _methods_FileInformation },
        { Py_tp_getset, _getset_FileInformation },
        { },
    };

    static PyType_Spec _type_spec_FileInformation =
    {
        "_winsdk_Windows_Storage_BulkAccess.FileInformation",
        sizeof(py::wrapper::Windows::Storage::BulkAccess::FileInformation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FileInformation
    };

    // ----- FileInformationFactory class --------------------
    constexpr const char* const _type_name_FileInformationFactory = "FileInformationFactory";

    static PyObject* _new_FileInformationFactory(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::IStorageQueryResultBase>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 1);

                winrt::Windows::Storage::BulkAccess::FileInformationFactory instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::IStorageQueryResultBase>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 1);
                auto param2 = py::convert_to<uint32_t>(args, 2);

                winrt::Windows::Storage::BulkAccess::FileInformationFactory instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 4)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::IStorageQueryResultBase>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 1);
                auto param2 = py::convert_to<uint32_t>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailOptions>(args, 3);

                winrt::Windows::Storage::BulkAccess::FileInformationFactory instance{ param0, param1, param2, param3 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 5)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::IStorageQueryResultBase>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 1);
                auto param2 = py::convert_to<uint32_t>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailOptions>(args, 3);
                auto param4 = py::convert_to<bool>(args, 4);

                winrt::Windows::Storage::BulkAccess::FileInformationFactory instance{ param0, param1, param2, param3, param4 };
                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_FileInformationFactory(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* FileInformationFactory_GetFilesAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetFilesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);

                return py::convert(self->obj.GetFilesAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformationFactory_GetFoldersAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetFoldersAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);

                return py::convert(self->obj.GetFoldersAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformationFactory_GetItemsAsync(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetItemsAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);

                return py::convert(self->obj.GetItemsAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformationFactory_GetVirtualizedFilesVector(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetVirtualizedFilesVector());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformationFactory_GetVirtualizedFoldersVector(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetVirtualizedFoldersVector());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FileInformationFactory_GetVirtualizedItemsVector(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetVirtualizedItemsVector());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _from_FileInformationFactory(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::BulkAccess::FileInformationFactory>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FileInformationFactory[] = {
        { "get_files_async", reinterpret_cast<PyCFunction>(FileInformationFactory_GetFilesAsync), METH_VARARGS, nullptr },
        { "get_folders_async", reinterpret_cast<PyCFunction>(FileInformationFactory_GetFoldersAsync), METH_VARARGS, nullptr },
        { "get_items_async", reinterpret_cast<PyCFunction>(FileInformationFactory_GetItemsAsync), METH_VARARGS, nullptr },
        { "get_virtualized_files_vector", reinterpret_cast<PyCFunction>(FileInformationFactory_GetVirtualizedFilesVector), METH_VARARGS, nullptr },
        { "get_virtualized_folders_vector", reinterpret_cast<PyCFunction>(FileInformationFactory_GetVirtualizedFoldersVector), METH_VARARGS, nullptr },
        { "get_virtualized_items_vector", reinterpret_cast<PyCFunction>(FileInformationFactory_GetVirtualizedItemsVector), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FileInformationFactory), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FileInformationFactory[] = {
        { }
    };

    static PyType_Slot _type_slots_FileInformationFactory[] = 
    {
        { Py_tp_new, _new_FileInformationFactory },
        { Py_tp_dealloc, _dealloc_FileInformationFactory },
        { Py_tp_methods, _methods_FileInformationFactory },
        { Py_tp_getset, _getset_FileInformationFactory },
        { },
    };

    static PyType_Spec _type_spec_FileInformationFactory =
    {
        "_winsdk_Windows_Storage_BulkAccess.FileInformationFactory",
        sizeof(py::wrapper::Windows::Storage::BulkAccess::FileInformationFactory),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FileInformationFactory
    };

    // ----- FolderInformation class --------------------
    constexpr const char* const _type_name_FolderInformation = "FolderInformation";

    static PyObject* _new_FolderInformation(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_FolderInformation);
        return nullptr;
    }

    static void _dealloc_FolderInformation(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* FolderInformation_AreQueryOptionsSupported(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::QueryOptions>(args, 0);

                return py::convert(self->obj.AreQueryOptionsSupported(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateFileAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.CreateFileAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::CreationCollisionOption>(args, 1);

                return py::convert(self->obj.CreateFileAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateFileQuery(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.CreateFileQuery());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFileQuery>(args, 0);

                return py::convert(self->obj.CreateFileQuery(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateFileQueryWithOptions(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::QueryOptions>(args, 0);

                return py::convert(self->obj.CreateFileQueryWithOptions(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateFolderAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.CreateFolderAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::CreationCollisionOption>(args, 1);

                return py::convert(self->obj.CreateFolderAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateFolderQuery(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.CreateFolderQuery());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFolderQuery>(args, 0);

                return py::convert(self->obj.CreateFolderQuery(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateFolderQueryWithOptions(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::QueryOptions>(args, 0);

                return py::convert(self->obj.CreateFolderQueryWithOptions(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateItemQuery(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.CreateItemQuery());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_CreateItemQueryWithOptions(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::QueryOptions>(args, 0);

                return py::convert(self->obj.CreateItemQueryWithOptions(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_DeleteAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.DeleteAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::StorageDeleteOption>(args, 0);

                return py::convert(self->obj.DeleteAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetBasicPropertiesAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetBasicPropertiesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetFileAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.GetFileAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetFilesAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetFilesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFileQuery>(args, 0);

                return py::convert(self->obj.GetFilesAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFileQuery>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);
                auto param2 = py::convert_to<uint32_t>(args, 2);

                return py::convert(self->obj.GetFilesAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetFolderAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.GetFolderAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetFoldersAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetFoldersAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFolderQuery>(args, 0);

                return py::convert(self->obj.GetFoldersAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFolderQuery>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);
                auto param2 = py::convert_to<uint32_t>(args, 2);

                return py::convert(self->obj.GetFoldersAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetIndexedStateAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetIndexedStateAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetItemAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.GetItemAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetItemsAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetItemsAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);

                return py::convert(self->obj.GetItemsAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetParentAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetParentAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_GetThumbnailAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 0);

                return py::convert(self->obj.GetThumbnailAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);

                return py::convert(self->obj.GetThumbnailAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailMode>(args, 0);
                auto param1 = py::convert_to<uint32_t>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Storage::FileProperties::ThumbnailOptions>(args, 2);

                return py::convert(self->obj.GetThumbnailAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_IsCommonFileQuerySupported(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFileQuery>(args, 0);

                return py::convert(self->obj.IsCommonFileQuerySupported(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_IsCommonFolderQuerySupported(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Search::CommonFolderQuery>(args, 0);

                return py::convert(self->obj.IsCommonFolderQuerySupported(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_IsEqual(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageItem>(args, 0);

                return py::convert(self->obj.IsEqual(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_IsOfType(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::StorageItemTypes>(args, 0);

                return py::convert(self->obj.IsOfType(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_RenameAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.RenameAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Storage::NameCollisionOption>(args, 1);

                return py::convert(self->obj.RenameAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_TryGetItemAsync(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.TryGetItemAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_BasicProperties(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BasicProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_DocumentProperties(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DocumentProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_ImageProperties(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ImageProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_MusicProperties(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.MusicProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_Thumbnail(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Thumbnail());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_VideoProperties(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.VideoProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_Attributes(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_DateCreated(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DateCreated());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_Name(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_Path(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Path());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_DisplayName(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_DisplayType(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_FolderRelativeId(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FolderRelativeId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_Properties(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Properties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_get_Provider(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Provider());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_add_PropertiesUpdated(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Storage::BulkAccess::IStorageItemInformation, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PropertiesUpdated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_remove_PropertiesUpdated(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PropertiesUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_add_ThumbnailUpdated(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Storage::BulkAccess::IStorageItemInformation, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ThumbnailUpdated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FolderInformation_remove_ThumbnailUpdated(py::wrapper::Windows::Storage::BulkAccess::FolderInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ThumbnailUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_FolderInformation(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::BulkAccess::FolderInformation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FolderInformation[] = {
        { "are_query_options_supported", reinterpret_cast<PyCFunction>(FolderInformation_AreQueryOptionsSupported), METH_VARARGS, nullptr },
        { "create_file_async", reinterpret_cast<PyCFunction>(FolderInformation_CreateFileAsync), METH_VARARGS, nullptr },
        { "create_file_query", reinterpret_cast<PyCFunction>(FolderInformation_CreateFileQuery), METH_VARARGS, nullptr },
        { "create_file_query_with_options", reinterpret_cast<PyCFunction>(FolderInformation_CreateFileQueryWithOptions), METH_VARARGS, nullptr },
        { "create_folder_async", reinterpret_cast<PyCFunction>(FolderInformation_CreateFolderAsync), METH_VARARGS, nullptr },
        { "create_folder_query", reinterpret_cast<PyCFunction>(FolderInformation_CreateFolderQuery), METH_VARARGS, nullptr },
        { "create_folder_query_with_options", reinterpret_cast<PyCFunction>(FolderInformation_CreateFolderQueryWithOptions), METH_VARARGS, nullptr },
        { "create_item_query", reinterpret_cast<PyCFunction>(FolderInformation_CreateItemQuery), METH_VARARGS, nullptr },
        { "create_item_query_with_options", reinterpret_cast<PyCFunction>(FolderInformation_CreateItemQueryWithOptions), METH_VARARGS, nullptr },
        { "delete_async", reinterpret_cast<PyCFunction>(FolderInformation_DeleteAsync), METH_VARARGS, nullptr },
        { "get_basic_properties_async", reinterpret_cast<PyCFunction>(FolderInformation_GetBasicPropertiesAsync), METH_VARARGS, nullptr },
        { "get_file_async", reinterpret_cast<PyCFunction>(FolderInformation_GetFileAsync), METH_VARARGS, nullptr },
        { "get_files_async", reinterpret_cast<PyCFunction>(FolderInformation_GetFilesAsync), METH_VARARGS, nullptr },
        { "get_folder_async", reinterpret_cast<PyCFunction>(FolderInformation_GetFolderAsync), METH_VARARGS, nullptr },
        { "get_folders_async", reinterpret_cast<PyCFunction>(FolderInformation_GetFoldersAsync), METH_VARARGS, nullptr },
        { "get_indexed_state_async", reinterpret_cast<PyCFunction>(FolderInformation_GetIndexedStateAsync), METH_VARARGS, nullptr },
        { "get_item_async", reinterpret_cast<PyCFunction>(FolderInformation_GetItemAsync), METH_VARARGS, nullptr },
        { "get_items_async", reinterpret_cast<PyCFunction>(FolderInformation_GetItemsAsync), METH_VARARGS, nullptr },
        { "get_parent_async", reinterpret_cast<PyCFunction>(FolderInformation_GetParentAsync), METH_VARARGS, nullptr },
        { "get_thumbnail_async", reinterpret_cast<PyCFunction>(FolderInformation_GetThumbnailAsync), METH_VARARGS, nullptr },
        { "is_common_file_query_supported", reinterpret_cast<PyCFunction>(FolderInformation_IsCommonFileQuerySupported), METH_VARARGS, nullptr },
        { "is_common_folder_query_supported", reinterpret_cast<PyCFunction>(FolderInformation_IsCommonFolderQuerySupported), METH_VARARGS, nullptr },
        { "is_equal", reinterpret_cast<PyCFunction>(FolderInformation_IsEqual), METH_VARARGS, nullptr },
        { "is_of_type", reinterpret_cast<PyCFunction>(FolderInformation_IsOfType), METH_VARARGS, nullptr },
        { "rename_async", reinterpret_cast<PyCFunction>(FolderInformation_RenameAsync), METH_VARARGS, nullptr },
        { "try_get_item_async", reinterpret_cast<PyCFunction>(FolderInformation_TryGetItemAsync), METH_VARARGS, nullptr },
        { "add_properties_updated", reinterpret_cast<PyCFunction>(FolderInformation_add_PropertiesUpdated), METH_O, nullptr },
        { "remove_properties_updated", reinterpret_cast<PyCFunction>(FolderInformation_remove_PropertiesUpdated), METH_O, nullptr },
        { "add_thumbnail_updated", reinterpret_cast<PyCFunction>(FolderInformation_add_ThumbnailUpdated), METH_O, nullptr },
        { "remove_thumbnail_updated", reinterpret_cast<PyCFunction>(FolderInformation_remove_ThumbnailUpdated), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FolderInformation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FolderInformation[] = {
        { "basic_properties", reinterpret_cast<getter>(FolderInformation_get_BasicProperties), nullptr, nullptr, nullptr },
        { "document_properties", reinterpret_cast<getter>(FolderInformation_get_DocumentProperties), nullptr, nullptr, nullptr },
        { "image_properties", reinterpret_cast<getter>(FolderInformation_get_ImageProperties), nullptr, nullptr, nullptr },
        { "music_properties", reinterpret_cast<getter>(FolderInformation_get_MusicProperties), nullptr, nullptr, nullptr },
        { "thumbnail", reinterpret_cast<getter>(FolderInformation_get_Thumbnail), nullptr, nullptr, nullptr },
        { "video_properties", reinterpret_cast<getter>(FolderInformation_get_VideoProperties), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(FolderInformation_get_Attributes), nullptr, nullptr, nullptr },
        { "date_created", reinterpret_cast<getter>(FolderInformation_get_DateCreated), nullptr, nullptr, nullptr },
        { "name", reinterpret_cast<getter>(FolderInformation_get_Name), nullptr, nullptr, nullptr },
        { "path", reinterpret_cast<getter>(FolderInformation_get_Path), nullptr, nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(FolderInformation_get_DisplayName), nullptr, nullptr, nullptr },
        { "display_type", reinterpret_cast<getter>(FolderInformation_get_DisplayType), nullptr, nullptr, nullptr },
        { "folder_relative_id", reinterpret_cast<getter>(FolderInformation_get_FolderRelativeId), nullptr, nullptr, nullptr },
        { "properties", reinterpret_cast<getter>(FolderInformation_get_Properties), nullptr, nullptr, nullptr },
        { "provider", reinterpret_cast<getter>(FolderInformation_get_Provider), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_FolderInformation[] = 
    {
        { Py_tp_new, _new_FolderInformation },
        { Py_tp_dealloc, _dealloc_FolderInformation },
        { Py_tp_methods, _methods_FolderInformation },
        { Py_tp_getset, _getset_FolderInformation },
        { },
    };

    static PyType_Spec _type_spec_FolderInformation =
    {
        "_winsdk_Windows_Storage_BulkAccess.FolderInformation",
        sizeof(py::wrapper::Windows::Storage::BulkAccess::FolderInformation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FolderInformation
    };

    // ----- IStorageItemInformation interface --------------------
    constexpr const char* const _type_name_IStorageItemInformation = "IStorageItemInformation";

    static PyObject* _new_IStorageItemInformation(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */)
    {
        py::set_invalid_activation_error(_type_name_IStorageItemInformation);
        return nullptr;
    }

    static void _dealloc_IStorageItemInformation(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IStorageItemInformation_get_BasicProperties(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BasicProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_get_DocumentProperties(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DocumentProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_get_ImageProperties(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ImageProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_get_MusicProperties(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.MusicProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_get_Thumbnail(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Thumbnail());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_get_VideoProperties(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.VideoProperties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_add_PropertiesUpdated(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Storage::BulkAccess::IStorageItemInformation, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PropertiesUpdated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_remove_PropertiesUpdated(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PropertiesUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_add_ThumbnailUpdated(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Storage::BulkAccess::IStorageItemInformation, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ThumbnailUpdated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IStorageItemInformation_remove_ThumbnailUpdated(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ThumbnailUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IStorageItemInformation(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::BulkAccess::IStorageItemInformation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IStorageItemInformation[] = {
        { "add_properties_updated", reinterpret_cast<PyCFunction>(IStorageItemInformation_add_PropertiesUpdated), METH_O, nullptr },
        { "remove_properties_updated", reinterpret_cast<PyCFunction>(IStorageItemInformation_remove_PropertiesUpdated), METH_O, nullptr },
        { "add_thumbnail_updated", reinterpret_cast<PyCFunction>(IStorageItemInformation_add_ThumbnailUpdated), METH_O, nullptr },
        { "remove_thumbnail_updated", reinterpret_cast<PyCFunction>(IStorageItemInformation_remove_ThumbnailUpdated), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IStorageItemInformation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IStorageItemInformation[] = {
        { "basic_properties", reinterpret_cast<getter>(IStorageItemInformation_get_BasicProperties), nullptr, nullptr, nullptr },
        { "document_properties", reinterpret_cast<getter>(IStorageItemInformation_get_DocumentProperties), nullptr, nullptr, nullptr },
        { "image_properties", reinterpret_cast<getter>(IStorageItemInformation_get_ImageProperties), nullptr, nullptr, nullptr },
        { "music_properties", reinterpret_cast<getter>(IStorageItemInformation_get_MusicProperties), nullptr, nullptr, nullptr },
        { "thumbnail", reinterpret_cast<getter>(IStorageItemInformation_get_Thumbnail), nullptr, nullptr, nullptr },
        { "video_properties", reinterpret_cast<getter>(IStorageItemInformation_get_VideoProperties), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IStorageItemInformation[] = 
    {
        { Py_tp_new, _new_IStorageItemInformation },
        { Py_tp_dealloc, _dealloc_IStorageItemInformation },
        { Py_tp_methods, _methods_IStorageItemInformation },
        { Py_tp_getset, _getset_IStorageItemInformation },
        { },
    };

    static PyType_Spec _type_spec_IStorageItemInformation =
    {
        "_winsdk_Windows_Storage_BulkAccess.IStorageItemInformation",
        sizeof(py::wrapper::Windows::Storage::BulkAccess::IStorageItemInformation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IStorageItemInformation
    };

    // ----- Windows.Storage.BulkAccess Initialization --------------------
    static int module_exec(PyObject* module) noexcept
    {
        try
        {
            py::pyobj_handle bases { PyTuple_Pack(1, py::winrt_type<py::Object>::python_type) };

            py::winrt_type<winrt::Windows::Storage::BulkAccess::FileInformation>::python_type = py::register_python_type(module, _type_name_FileInformation, &_type_spec_FileInformation, bases.get());
            py::winrt_type<winrt::Windows::Storage::BulkAccess::FileInformationFactory>::python_type = py::register_python_type(module, _type_name_FileInformationFactory, &_type_spec_FileInformationFactory, bases.get());
            py::winrt_type<winrt::Windows::Storage::BulkAccess::FolderInformation>::python_type = py::register_python_type(module, _type_name_FolderInformation, &_type_spec_FolderInformation, bases.get());
            py::winrt_type<winrt::Windows::Storage::BulkAccess::IStorageItemInformation>::python_type = py::register_python_type(module, _type_name_IStorageItemInformation, &_type_spec_IStorageItemInformation, bases.get());

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

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

    PyDoc_STRVAR(module_doc, "Windows.Storage.BulkAccess");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Storage_BulkAccess",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::Storage::BulkAccess

PyMODINIT_FUNC
PyInit__winsdk_Windows_Storage_BulkAccess (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Storage::BulkAccess::module_def);
}
