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

#include "pybase.h"
#include "py.Windows.Web.Syndication.h"

PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationAttribute>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationCategory>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationClient>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationContent>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationError>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationFeed>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationGenerator>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationItem>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationLink>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationNode>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationPerson>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::SyndicationText>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::ISyndicationClient>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::ISyndicationNode>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::ISyndicationText>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::RetrievalProgress>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Web::Syndication::TransferProgress>::python_type;

PyObject* py::converter<winrt::Windows::Web::Syndication::RetrievalProgress>::convert(winrt::Windows::Web::Syndication::RetrievalProgress instance) noexcept
{
    return py::wrap_struct(instance, py::get_python_type<winrt::Windows::Web::Syndication::RetrievalProgress>());
}
winrt::Windows::Web::Syndication::RetrievalProgress py::converter<winrt::Windows::Web::Syndication::RetrievalProgress>::convert_to(PyObject* obj)
{
    throw_if_pyobj_null(obj);

    if (Py_TYPE(obj) == py::get_python_type<winrt::Windows::Web::Syndication::RetrievalProgress>())
    {
        return reinterpret_cast<py::winrt_struct_wrapper<winrt::Windows::Web::Syndication::RetrievalProgress>*>(obj)->obj;
    }

    if (!PyDict_Check(obj))
    {
        throw winrt::hresult_invalid_argument();
    }

    winrt::Windows::Web::Syndication::RetrievalProgress return_value{};

    PyObject* py_BytesRetrieved = PyDict_GetItemString(obj, "bytes_retrieved");
    if (!py_BytesRetrieved) { throw winrt::hresult_invalid_argument(); }
    return_value.BytesRetrieved = converter<uint32_t>::convert_to(py_BytesRetrieved);

    PyObject* py_TotalBytesToRetrieve = PyDict_GetItemString(obj, "total_bytes_to_retrieve");
    if (!py_TotalBytesToRetrieve) { throw winrt::hresult_invalid_argument(); }
    return_value.TotalBytesToRetrieve = converter<uint32_t>::convert_to(py_TotalBytesToRetrieve);

    return return_value;
}

PyObject* py::converter<winrt::Windows::Web::Syndication::TransferProgress>::convert(winrt::Windows::Web::Syndication::TransferProgress instance) noexcept
{
    return py::wrap_struct(instance, py::get_python_type<winrt::Windows::Web::Syndication::TransferProgress>());
}
winrt::Windows::Web::Syndication::TransferProgress py::converter<winrt::Windows::Web::Syndication::TransferProgress>::convert_to(PyObject* obj)
{
    throw_if_pyobj_null(obj);

    if (Py_TYPE(obj) == py::get_python_type<winrt::Windows::Web::Syndication::TransferProgress>())
    {
        return reinterpret_cast<py::winrt_struct_wrapper<winrt::Windows::Web::Syndication::TransferProgress>*>(obj)->obj;
    }

    if (!PyDict_Check(obj))
    {
        throw winrt::hresult_invalid_argument();
    }

    winrt::Windows::Web::Syndication::TransferProgress return_value{};

    PyObject* py_BytesSent = PyDict_GetItemString(obj, "bytes_sent");
    if (!py_BytesSent) { throw winrt::hresult_invalid_argument(); }
    return_value.BytesSent = converter<uint32_t>::convert_to(py_BytesSent);

    PyObject* py_TotalBytesToSend = PyDict_GetItemString(obj, "total_bytes_to_send");
    if (!py_TotalBytesToSend) { throw winrt::hresult_invalid_argument(); }
    return_value.TotalBytesToSend = converter<uint32_t>::convert_to(py_TotalBytesToSend);

    PyObject* py_BytesRetrieved = PyDict_GetItemString(obj, "bytes_retrieved");
    if (!py_BytesRetrieved) { throw winrt::hresult_invalid_argument(); }
    return_value.BytesRetrieved = converter<uint32_t>::convert_to(py_BytesRetrieved);

    PyObject* py_TotalBytesToRetrieve = PyDict_GetItemString(obj, "total_bytes_to_retrieve");
    if (!py_TotalBytesToRetrieve) { throw winrt::hresult_invalid_argument(); }
    return_value.TotalBytesToRetrieve = converter<uint32_t>::convert_to(py_TotalBytesToRetrieve);

    return return_value;
}

namespace py::cpp::Windows::Web::Syndication
{
    // ----- SyndicationAttribute class --------------------
    constexpr const char* const _type_name_SyndicationAttribute = "SyndicationAttribute";

    static PyObject* _new_SyndicationAttribute(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 == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);

                winrt::Windows::Web::Syndication::SyndicationAttribute instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationAttribute 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_SyndicationAttribute(py::wrapper::Windows::Web::Syndication::SyndicationAttribute* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationAttribute_get_Value(py::wrapper::Windows::Web::Syndication::SyndicationAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Value());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationAttribute_put_Value(py::wrapper::Windows::Web::Syndication::SyndicationAttribute* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Value(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationAttribute_get_Namespace(py::wrapper::Windows::Web::Syndication::SyndicationAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Namespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationAttribute_put_Namespace(py::wrapper::Windows::Web::Syndication::SyndicationAttribute* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Namespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationAttribute_get_Name(py::wrapper::Windows::Web::Syndication::SyndicationAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationAttribute_put_Name(py::wrapper::Windows::Web::Syndication::SyndicationAttribute* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Name(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_SyndicationAttribute(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::Web::Syndication::SyndicationAttribute>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationAttribute[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationAttribute), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationAttribute[] = {
        { "value", reinterpret_cast<getter>(SyndicationAttribute_get_Value), reinterpret_cast<setter>(SyndicationAttribute_put_Value), nullptr, nullptr },
        { "namespace", reinterpret_cast<getter>(SyndicationAttribute_get_Namespace), reinterpret_cast<setter>(SyndicationAttribute_put_Namespace), nullptr, nullptr },
        { "name", reinterpret_cast<getter>(SyndicationAttribute_get_Name), reinterpret_cast<setter>(SyndicationAttribute_put_Name), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationAttribute[] = 
    {
        { Py_tp_new, _new_SyndicationAttribute },
        { Py_tp_dealloc, _dealloc_SyndicationAttribute },
        { Py_tp_methods, _methods_SyndicationAttribute },
        { Py_tp_getset, _getset_SyndicationAttribute },
        { },
    };

    static PyType_Spec _type_spec_SyndicationAttribute =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationAttribute",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationAttribute),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationAttribute
    };

    // ----- SyndicationCategory class --------------------
    constexpr const char* const _type_name_SyndicationCategory = "SyndicationCategory";

    static PyObject* _new_SyndicationCategory(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                winrt::Windows::Web::Syndication::SyndicationCategory instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);

                winrt::Windows::Web::Syndication::SyndicationCategory instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationCategory 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_SyndicationCategory(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationCategory_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationCategory_get_Term(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Term());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_Term(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Term(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_Scheme(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Scheme());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_Scheme(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Scheme(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_Label(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Label());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_Label(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Label(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationCategory_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationCategory_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationCategory_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationCategory* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_SyndicationCategory(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::Web::Syndication::SyndicationCategory>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationCategory[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationCategory_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationCategory), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationCategory[] = {
        { "term", reinterpret_cast<getter>(SyndicationCategory_get_Term), reinterpret_cast<setter>(SyndicationCategory_put_Term), nullptr, nullptr },
        { "scheme", reinterpret_cast<getter>(SyndicationCategory_get_Scheme), reinterpret_cast<setter>(SyndicationCategory_put_Scheme), nullptr, nullptr },
        { "label", reinterpret_cast<getter>(SyndicationCategory_get_Label), reinterpret_cast<setter>(SyndicationCategory_put_Label), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(SyndicationCategory_get_NodeValue), reinterpret_cast<setter>(SyndicationCategory_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationCategory_get_NodeNamespace), reinterpret_cast<setter>(SyndicationCategory_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationCategory_get_NodeName), reinterpret_cast<setter>(SyndicationCategory_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationCategory_get_Language), reinterpret_cast<setter>(SyndicationCategory_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationCategory_get_BaseUri), reinterpret_cast<setter>(SyndicationCategory_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationCategory_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationCategory_get_ElementExtensions), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationCategory[] = 
    {
        { Py_tp_new, _new_SyndicationCategory },
        { Py_tp_dealloc, _dealloc_SyndicationCategory },
        { Py_tp_methods, _methods_SyndicationCategory },
        { Py_tp_getset, _getset_SyndicationCategory },
        { },
    };

    static PyType_Spec _type_spec_SyndicationCategory =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationCategory",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationCategory),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationCategory
    };

    // ----- SyndicationClient class --------------------
    constexpr const char* const _type_name_SyndicationClient = "SyndicationClient";

    static PyObject* _new_SyndicationClient(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Security::Credentials::PasswordCredential>(args, 0);

                winrt::Windows::Web::Syndication::SyndicationClient instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationClient 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_SyndicationClient(py::wrapper::Windows::Web::Syndication::SyndicationClient* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationClient_RetrieveFeedAsync(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationClient_SetRequestHeader(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationClient_get_Timeout(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Timeout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationClient_put_Timeout(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<uint32_t>(arg);

            self->obj.Timeout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationClient_get_ServerCredential(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ServerCredential());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationClient_put_ServerCredential(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Security::Credentials::PasswordCredential>(arg);

            self->obj.ServerCredential(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationClient_get_ProxyCredential(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProxyCredential());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationClient_put_ProxyCredential(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Security::Credentials::PasswordCredential>(arg);

            self->obj.ProxyCredential(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationClient_get_MaxResponseBufferSize(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.MaxResponseBufferSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationClient_put_MaxResponseBufferSize(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<uint32_t>(arg);

            self->obj.MaxResponseBufferSize(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationClient_get_BypassCacheOnRetrieve(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BypassCacheOnRetrieve());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationClient_put_BypassCacheOnRetrieve(py::wrapper::Windows::Web::Syndication::SyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<bool>(arg);

            self->obj.BypassCacheOnRetrieve(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_SyndicationClient(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::Web::Syndication::SyndicationClient>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationClient[] = {
        { "retrieve_feed_async", reinterpret_cast<PyCFunction>(SyndicationClient_RetrieveFeedAsync), METH_VARARGS, nullptr },
        { "set_request_header", reinterpret_cast<PyCFunction>(SyndicationClient_SetRequestHeader), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationClient), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationClient[] = {
        { "timeout", reinterpret_cast<getter>(SyndicationClient_get_Timeout), reinterpret_cast<setter>(SyndicationClient_put_Timeout), nullptr, nullptr },
        { "server_credential", reinterpret_cast<getter>(SyndicationClient_get_ServerCredential), reinterpret_cast<setter>(SyndicationClient_put_ServerCredential), nullptr, nullptr },
        { "proxy_credential", reinterpret_cast<getter>(SyndicationClient_get_ProxyCredential), reinterpret_cast<setter>(SyndicationClient_put_ProxyCredential), nullptr, nullptr },
        { "max_response_buffer_size", reinterpret_cast<getter>(SyndicationClient_get_MaxResponseBufferSize), reinterpret_cast<setter>(SyndicationClient_put_MaxResponseBufferSize), nullptr, nullptr },
        { "bypass_cache_on_retrieve", reinterpret_cast<getter>(SyndicationClient_get_BypassCacheOnRetrieve), reinterpret_cast<setter>(SyndicationClient_put_BypassCacheOnRetrieve), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationClient[] = 
    {
        { Py_tp_new, _new_SyndicationClient },
        { Py_tp_dealloc, _dealloc_SyndicationClient },
        { Py_tp_methods, _methods_SyndicationClient },
        { Py_tp_getset, _getset_SyndicationClient },
        { },
    };

    static PyType_Spec _type_spec_SyndicationClient =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationClient",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationClient),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationClient
    };

    // ----- SyndicationContent class --------------------
    constexpr const char* const _type_name_SyndicationContent = "SyndicationContent";

    static PyObject* _new_SyndicationContent(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::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Web::Syndication::SyndicationTextType>(args, 1);

                winrt::Windows::Web::Syndication::SyndicationContent instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(args, 0);

                winrt::Windows::Web::Syndication::SyndicationContent instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationContent 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_SyndicationContent(py::wrapper::Windows::Web::Syndication::SyndicationContent* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationContent_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationContent_get_SourceUri(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SourceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_SourceUri(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.SourceUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationContent_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationContent_get_Text(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_Text(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_Type(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Type());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_Type(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Type(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationContent_get_Xml(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Xml());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationContent_put_Xml(py::wrapper::Windows::Web::Syndication::SyndicationContent* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlDocument>(arg);

            self->obj.Xml(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_SyndicationContent(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::Web::Syndication::SyndicationContent>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationContent[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationContent_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationContent), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationContent[] = {
        { "source_uri", reinterpret_cast<getter>(SyndicationContent_get_SourceUri), reinterpret_cast<setter>(SyndicationContent_put_SourceUri), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(SyndicationContent_get_NodeValue), reinterpret_cast<setter>(SyndicationContent_put_NodeValue), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationContent_get_BaseUri), reinterpret_cast<setter>(SyndicationContent_put_BaseUri), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationContent_get_Language), reinterpret_cast<setter>(SyndicationContent_put_Language), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationContent_get_NodeName), reinterpret_cast<setter>(SyndicationContent_put_NodeName), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationContent_get_NodeNamespace), reinterpret_cast<setter>(SyndicationContent_put_NodeNamespace), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationContent_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationContent_get_ElementExtensions), nullptr, nullptr, nullptr },
        { "text", reinterpret_cast<getter>(SyndicationContent_get_Text), reinterpret_cast<setter>(SyndicationContent_put_Text), nullptr, nullptr },
        { "type", reinterpret_cast<getter>(SyndicationContent_get_Type), reinterpret_cast<setter>(SyndicationContent_put_Type), nullptr, nullptr },
        { "xml", reinterpret_cast<getter>(SyndicationContent_get_Xml), reinterpret_cast<setter>(SyndicationContent_put_Xml), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationContent[] = 
    {
        { Py_tp_new, _new_SyndicationContent },
        { Py_tp_dealloc, _dealloc_SyndicationContent },
        { Py_tp_methods, _methods_SyndicationContent },
        { Py_tp_getset, _getset_SyndicationContent },
        { },
    };

    static PyType_Spec _type_spec_SyndicationContent =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationContent",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationContent),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationContent
    };

    // ----- SyndicationError class --------------------
    constexpr const char* const _type_name_SyndicationError = "SyndicationError";

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

    static PyObject* SyndicationError_GetStatus(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::Web::Syndication::SyndicationError::GetStatus(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationError[] = {
        { "get_status", reinterpret_cast<PyCFunction>(SyndicationError_GetStatus), METH_VARARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationError[] = {
        { }
    };

    static PyType_Slot _type_slots_SyndicationError[] = 
    {
        { Py_tp_new, _new_SyndicationError },
        { Py_tp_methods, _methods_SyndicationError },
        { Py_tp_getset, _getset_SyndicationError },
        { },
    };

    static PyType_Spec _type_spec_SyndicationError =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationError",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationError
    };

    // ----- SyndicationFeed class --------------------
    constexpr const char* const _type_name_SyndicationFeed = "SyndicationFeed";

    static PyObject* _new_SyndicationFeed(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 == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Uri>(args, 2);

                winrt::Windows::Web::Syndication::SyndicationFeed instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationFeed 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_SyndicationFeed(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationFeed_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationFeed_Load(py::wrapper::Windows::Web::Syndication::SyndicationFeed* 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);

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

    static PyObject* SyndicationFeed_LoadFromXml(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlDocument>(args, 0);

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

    static PyObject* SyndicationFeed_get_Title(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Title());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_Title(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::ISyndicationText>(arg);

            self->obj.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_Subtitle(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Subtitle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_Subtitle(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::ISyndicationText>(arg);

            self->obj.Subtitle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_Rights(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Rights());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_Rights(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::ISyndicationText>(arg);

            self->obj.Rights(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_Generator(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Generator());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_Generator(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::SyndicationGenerator>(arg);

            self->obj.Generator(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_LastUpdatedTime(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastUpdatedTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_LastUpdatedTime(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::DateTime>(arg);

            self->obj.LastUpdatedTime(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_ImageUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ImageUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_ImageUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.ImageUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_IconUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IconUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_IconUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.IconUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_Id(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_Id(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Id(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_FirstUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_Items(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_LastUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_Links(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Links());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_NextUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_PreviousUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_Categories(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Categories());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_SourceFormat(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SourceFormat());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_Contributors(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Contributors());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_Authors(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Authors());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationFeed_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationFeed_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationFeed_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationFeed* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_SyndicationFeed(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::Web::Syndication::SyndicationFeed>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationFeed[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationFeed_GetXmlDocument), METH_VARARGS, nullptr },
        { "load", reinterpret_cast<PyCFunction>(SyndicationFeed_Load), METH_VARARGS, nullptr },
        { "load_from_xml", reinterpret_cast<PyCFunction>(SyndicationFeed_LoadFromXml), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationFeed), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationFeed[] = {
        { "title", reinterpret_cast<getter>(SyndicationFeed_get_Title), reinterpret_cast<setter>(SyndicationFeed_put_Title), nullptr, nullptr },
        { "subtitle", reinterpret_cast<getter>(SyndicationFeed_get_Subtitle), reinterpret_cast<setter>(SyndicationFeed_put_Subtitle), nullptr, nullptr },
        { "rights", reinterpret_cast<getter>(SyndicationFeed_get_Rights), reinterpret_cast<setter>(SyndicationFeed_put_Rights), nullptr, nullptr },
        { "generator", reinterpret_cast<getter>(SyndicationFeed_get_Generator), reinterpret_cast<setter>(SyndicationFeed_put_Generator), nullptr, nullptr },
        { "last_updated_time", reinterpret_cast<getter>(SyndicationFeed_get_LastUpdatedTime), reinterpret_cast<setter>(SyndicationFeed_put_LastUpdatedTime), nullptr, nullptr },
        { "image_uri", reinterpret_cast<getter>(SyndicationFeed_get_ImageUri), reinterpret_cast<setter>(SyndicationFeed_put_ImageUri), nullptr, nullptr },
        { "icon_uri", reinterpret_cast<getter>(SyndicationFeed_get_IconUri), reinterpret_cast<setter>(SyndicationFeed_put_IconUri), nullptr, nullptr },
        { "id", reinterpret_cast<getter>(SyndicationFeed_get_Id), reinterpret_cast<setter>(SyndicationFeed_put_Id), nullptr, nullptr },
        { "first_uri", reinterpret_cast<getter>(SyndicationFeed_get_FirstUri), nullptr, nullptr, nullptr },
        { "items", reinterpret_cast<getter>(SyndicationFeed_get_Items), nullptr, nullptr, nullptr },
        { "last_uri", reinterpret_cast<getter>(SyndicationFeed_get_LastUri), nullptr, nullptr, nullptr },
        { "links", reinterpret_cast<getter>(SyndicationFeed_get_Links), nullptr, nullptr, nullptr },
        { "next_uri", reinterpret_cast<getter>(SyndicationFeed_get_NextUri), nullptr, nullptr, nullptr },
        { "previous_uri", reinterpret_cast<getter>(SyndicationFeed_get_PreviousUri), nullptr, nullptr, nullptr },
        { "categories", reinterpret_cast<getter>(SyndicationFeed_get_Categories), nullptr, nullptr, nullptr },
        { "source_format", reinterpret_cast<getter>(SyndicationFeed_get_SourceFormat), nullptr, nullptr, nullptr },
        { "contributors", reinterpret_cast<getter>(SyndicationFeed_get_Contributors), nullptr, nullptr, nullptr },
        { "authors", reinterpret_cast<getter>(SyndicationFeed_get_Authors), nullptr, nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(SyndicationFeed_get_NodeValue), reinterpret_cast<setter>(SyndicationFeed_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationFeed_get_NodeNamespace), reinterpret_cast<setter>(SyndicationFeed_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationFeed_get_NodeName), reinterpret_cast<setter>(SyndicationFeed_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationFeed_get_Language), reinterpret_cast<setter>(SyndicationFeed_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationFeed_get_BaseUri), reinterpret_cast<setter>(SyndicationFeed_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationFeed_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationFeed_get_ElementExtensions), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationFeed[] = 
    {
        { Py_tp_new, _new_SyndicationFeed },
        { Py_tp_dealloc, _dealloc_SyndicationFeed },
        { Py_tp_methods, _methods_SyndicationFeed },
        { Py_tp_getset, _getset_SyndicationFeed },
        { },
    };

    static PyType_Spec _type_spec_SyndicationFeed =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationFeed",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationFeed),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationFeed
    };

    // ----- SyndicationGenerator class --------------------
    constexpr const char* const _type_name_SyndicationGenerator = "SyndicationGenerator";

    static PyObject* _new_SyndicationGenerator(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                winrt::Windows::Web::Syndication::SyndicationGenerator instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationGenerator 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_SyndicationGenerator(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationGenerator_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationGenerator_get_Version(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Version());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_Version(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Version(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_Uri(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Uri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_Uri(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.Uri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_Text(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_Text(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationGenerator_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationGenerator_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationGenerator_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationGenerator* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_SyndicationGenerator(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::Web::Syndication::SyndicationGenerator>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationGenerator[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationGenerator_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationGenerator), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationGenerator[] = {
        { "version", reinterpret_cast<getter>(SyndicationGenerator_get_Version), reinterpret_cast<setter>(SyndicationGenerator_put_Version), nullptr, nullptr },
        { "uri", reinterpret_cast<getter>(SyndicationGenerator_get_Uri), reinterpret_cast<setter>(SyndicationGenerator_put_Uri), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(SyndicationGenerator_get_Text), reinterpret_cast<setter>(SyndicationGenerator_put_Text), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(SyndicationGenerator_get_NodeValue), reinterpret_cast<setter>(SyndicationGenerator_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationGenerator_get_NodeNamespace), reinterpret_cast<setter>(SyndicationGenerator_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationGenerator_get_NodeName), reinterpret_cast<setter>(SyndicationGenerator_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationGenerator_get_Language), reinterpret_cast<setter>(SyndicationGenerator_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationGenerator_get_BaseUri), reinterpret_cast<setter>(SyndicationGenerator_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationGenerator_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationGenerator_get_ElementExtensions), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationGenerator[] = 
    {
        { Py_tp_new, _new_SyndicationGenerator },
        { Py_tp_dealloc, _dealloc_SyndicationGenerator },
        { Py_tp_methods, _methods_SyndicationGenerator },
        { Py_tp_getset, _getset_SyndicationGenerator },
        { },
    };

    static PyType_Spec _type_spec_SyndicationGenerator =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationGenerator",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationGenerator),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationGenerator
    };

    // ----- SyndicationItem class --------------------
    constexpr const char* const _type_name_SyndicationItem = "SyndicationItem";

    static PyObject* _new_SyndicationItem(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 == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Web::Syndication::SyndicationContent>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Uri>(args, 2);

                winrt::Windows::Web::Syndication::SyndicationItem instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationItem 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_SyndicationItem(py::wrapper::Windows::Web::Syndication::SyndicationItem* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationItem_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationItem_Load(py::wrapper::Windows::Web::Syndication::SyndicationItem* 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);

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

    static PyObject* SyndicationItem_LoadFromXml(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlDocument>(args, 0);

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

    static PyObject* SyndicationItem_get_Title(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Title());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_Title(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::ISyndicationText>(arg);

            self->obj.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_Source(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Source());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_Source(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::SyndicationFeed>(arg);

            self->obj.Source(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_Rights(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Rights());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_Rights(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::ISyndicationText>(arg);

            self->obj.Rights(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_Summary(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Summary());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_Summary(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::ISyndicationText>(arg);

            self->obj.Summary(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_PublishedDate(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PublishedDate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_PublishedDate(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::DateTime>(arg);

            self->obj.PublishedDate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_CommentsUri(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.CommentsUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_CommentsUri(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.CommentsUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_Id(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_Id(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Id(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_LastUpdatedTime(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastUpdatedTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_LastUpdatedTime(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::DateTime>(arg);

            self->obj.LastUpdatedTime(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_Content(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_Content(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Web::Syndication::SyndicationContent>(arg);

            self->obj.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_EditUri(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.EditUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_Links(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Links());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_Authors(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Authors());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_Categories(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Categories());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_Contributors(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Contributors());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_ItemUri(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ItemUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_ETag(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ETag());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_EditMediaUri(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.EditMediaUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationItem_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationItem_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationItem_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationItem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_SyndicationItem(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::Web::Syndication::SyndicationItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationItem[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationItem_GetXmlDocument), METH_VARARGS, nullptr },
        { "load", reinterpret_cast<PyCFunction>(SyndicationItem_Load), METH_VARARGS, nullptr },
        { "load_from_xml", reinterpret_cast<PyCFunction>(SyndicationItem_LoadFromXml), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationItem[] = {
        { "title", reinterpret_cast<getter>(SyndicationItem_get_Title), reinterpret_cast<setter>(SyndicationItem_put_Title), nullptr, nullptr },
        { "source", reinterpret_cast<getter>(SyndicationItem_get_Source), reinterpret_cast<setter>(SyndicationItem_put_Source), nullptr, nullptr },
        { "rights", reinterpret_cast<getter>(SyndicationItem_get_Rights), reinterpret_cast<setter>(SyndicationItem_put_Rights), nullptr, nullptr },
        { "summary", reinterpret_cast<getter>(SyndicationItem_get_Summary), reinterpret_cast<setter>(SyndicationItem_put_Summary), nullptr, nullptr },
        { "published_date", reinterpret_cast<getter>(SyndicationItem_get_PublishedDate), reinterpret_cast<setter>(SyndicationItem_put_PublishedDate), nullptr, nullptr },
        { "comments_uri", reinterpret_cast<getter>(SyndicationItem_get_CommentsUri), reinterpret_cast<setter>(SyndicationItem_put_CommentsUri), nullptr, nullptr },
        { "id", reinterpret_cast<getter>(SyndicationItem_get_Id), reinterpret_cast<setter>(SyndicationItem_put_Id), nullptr, nullptr },
        { "last_updated_time", reinterpret_cast<getter>(SyndicationItem_get_LastUpdatedTime), reinterpret_cast<setter>(SyndicationItem_put_LastUpdatedTime), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(SyndicationItem_get_Content), reinterpret_cast<setter>(SyndicationItem_put_Content), nullptr, nullptr },
        { "edit_uri", reinterpret_cast<getter>(SyndicationItem_get_EditUri), nullptr, nullptr, nullptr },
        { "links", reinterpret_cast<getter>(SyndicationItem_get_Links), nullptr, nullptr, nullptr },
        { "authors", reinterpret_cast<getter>(SyndicationItem_get_Authors), nullptr, nullptr, nullptr },
        { "categories", reinterpret_cast<getter>(SyndicationItem_get_Categories), nullptr, nullptr, nullptr },
        { "contributors", reinterpret_cast<getter>(SyndicationItem_get_Contributors), nullptr, nullptr, nullptr },
        { "item_uri", reinterpret_cast<getter>(SyndicationItem_get_ItemUri), nullptr, nullptr, nullptr },
        { "e_tag", reinterpret_cast<getter>(SyndicationItem_get_ETag), nullptr, nullptr, nullptr },
        { "edit_media_uri", reinterpret_cast<getter>(SyndicationItem_get_EditMediaUri), nullptr, nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(SyndicationItem_get_NodeValue), reinterpret_cast<setter>(SyndicationItem_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationItem_get_NodeNamespace), reinterpret_cast<setter>(SyndicationItem_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationItem_get_NodeName), reinterpret_cast<setter>(SyndicationItem_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationItem_get_Language), reinterpret_cast<setter>(SyndicationItem_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationItem_get_BaseUri), reinterpret_cast<setter>(SyndicationItem_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationItem_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationItem_get_ElementExtensions), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationItem[] = 
    {
        { Py_tp_new, _new_SyndicationItem },
        { Py_tp_dealloc, _dealloc_SyndicationItem },
        { Py_tp_methods, _methods_SyndicationItem },
        { Py_tp_getset, _getset_SyndicationItem },
        { },
    };

    static PyType_Spec _type_spec_SyndicationItem =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationItem",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationItem
    };

    // ----- SyndicationLink class --------------------
    constexpr const char* const _type_name_SyndicationLink = "SyndicationLink";

    static PyObject* _new_SyndicationLink(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(args, 0);

                winrt::Windows::Web::Syndication::SyndicationLink instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 5)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);
                auto param3 = py::convert_to<winrt::hstring>(args, 3);
                auto param4 = py::convert_to<uint32_t>(args, 4);

                winrt::Windows::Web::Syndication::SyndicationLink instance{ param0, param1, param2, param3, param4 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationLink 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_SyndicationLink(py::wrapper::Windows::Web::Syndication::SyndicationLink* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationLink_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationLink_get_Uri(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Uri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_Uri(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.Uri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_Title(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Title());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_Title(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_ResourceLanguage(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ResourceLanguage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_ResourceLanguage(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.ResourceLanguage(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_Relationship(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Relationship());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_Relationship(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Relationship(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_MediaType(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.MediaType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_MediaType(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.MediaType(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_Length(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_Length(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<uint32_t>(arg);

            self->obj.Length(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationLink_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationLink_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationLink_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationLink* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_SyndicationLink(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::Web::Syndication::SyndicationLink>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationLink[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationLink_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationLink), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationLink[] = {
        { "uri", reinterpret_cast<getter>(SyndicationLink_get_Uri), reinterpret_cast<setter>(SyndicationLink_put_Uri), nullptr, nullptr },
        { "title", reinterpret_cast<getter>(SyndicationLink_get_Title), reinterpret_cast<setter>(SyndicationLink_put_Title), nullptr, nullptr },
        { "resource_language", reinterpret_cast<getter>(SyndicationLink_get_ResourceLanguage), reinterpret_cast<setter>(SyndicationLink_put_ResourceLanguage), nullptr, nullptr },
        { "relationship", reinterpret_cast<getter>(SyndicationLink_get_Relationship), reinterpret_cast<setter>(SyndicationLink_put_Relationship), nullptr, nullptr },
        { "media_type", reinterpret_cast<getter>(SyndicationLink_get_MediaType), reinterpret_cast<setter>(SyndicationLink_put_MediaType), nullptr, nullptr },
        { "length", reinterpret_cast<getter>(SyndicationLink_get_Length), reinterpret_cast<setter>(SyndicationLink_put_Length), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(SyndicationLink_get_NodeValue), reinterpret_cast<setter>(SyndicationLink_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationLink_get_NodeNamespace), reinterpret_cast<setter>(SyndicationLink_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationLink_get_NodeName), reinterpret_cast<setter>(SyndicationLink_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationLink_get_Language), reinterpret_cast<setter>(SyndicationLink_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationLink_get_BaseUri), reinterpret_cast<setter>(SyndicationLink_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationLink_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationLink_get_ElementExtensions), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationLink[] = 
    {
        { Py_tp_new, _new_SyndicationLink },
        { Py_tp_dealloc, _dealloc_SyndicationLink },
        { Py_tp_methods, _methods_SyndicationLink },
        { Py_tp_getset, _getset_SyndicationLink },
        { },
    };

    static PyType_Spec _type_spec_SyndicationLink =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationLink",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationLink),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationLink
    };

    // ----- SyndicationNode class --------------------
    constexpr const char* const _type_name_SyndicationNode = "SyndicationNode";

    static PyObject* _new_SyndicationNode(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 == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);

                winrt::Windows::Web::Syndication::SyndicationNode instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationNode 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_SyndicationNode(py::wrapper::Windows::Web::Syndication::SyndicationNode* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationNode_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationNode_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationNode_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationNode_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationNode_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationNode_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationNode_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationNode_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationNode_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationNode_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationNode_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationNode_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationNode_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_SyndicationNode(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::Web::Syndication::SyndicationNode>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationNode[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationNode_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationNode), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationNode[] = {
        { "node_value", reinterpret_cast<getter>(SyndicationNode_get_NodeValue), reinterpret_cast<setter>(SyndicationNode_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationNode_get_NodeNamespace), reinterpret_cast<setter>(SyndicationNode_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationNode_get_NodeName), reinterpret_cast<setter>(SyndicationNode_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationNode_get_Language), reinterpret_cast<setter>(SyndicationNode_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationNode_get_BaseUri), reinterpret_cast<setter>(SyndicationNode_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationNode_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationNode_get_ElementExtensions), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationNode[] = 
    {
        { Py_tp_new, _new_SyndicationNode },
        { Py_tp_dealloc, _dealloc_SyndicationNode },
        { Py_tp_methods, _methods_SyndicationNode },
        { Py_tp_getset, _getset_SyndicationNode },
        { },
    };

    static PyType_Spec _type_spec_SyndicationNode =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationNode",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationNode),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationNode
    };

    // ----- SyndicationPerson class --------------------
    constexpr const char* const _type_name_SyndicationPerson = "SyndicationPerson";

    static PyObject* _new_SyndicationPerson(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                winrt::Windows::Web::Syndication::SyndicationPerson instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::Uri>(args, 2);

                winrt::Windows::Web::Syndication::SyndicationPerson instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationPerson 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_SyndicationPerson(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationPerson_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationPerson_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationPerson_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationPerson_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationPerson_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationPerson_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationPerson_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationPerson_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationPerson_get_Uri(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Uri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_Uri(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.Uri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationPerson_get_Name(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_Name(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Name(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationPerson_get_Email(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Email());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationPerson_put_Email(py::wrapper::Windows::Web::Syndication::SyndicationPerson* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Email(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_SyndicationPerson(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::Web::Syndication::SyndicationPerson>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationPerson[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationPerson_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationPerson), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationPerson[] = {
        { "node_value", reinterpret_cast<getter>(SyndicationPerson_get_NodeValue), reinterpret_cast<setter>(SyndicationPerson_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationPerson_get_NodeNamespace), reinterpret_cast<setter>(SyndicationPerson_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationPerson_get_NodeName), reinterpret_cast<setter>(SyndicationPerson_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationPerson_get_Language), reinterpret_cast<setter>(SyndicationPerson_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationPerson_get_BaseUri), reinterpret_cast<setter>(SyndicationPerson_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationPerson_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationPerson_get_ElementExtensions), nullptr, nullptr, nullptr },
        { "uri", reinterpret_cast<getter>(SyndicationPerson_get_Uri), reinterpret_cast<setter>(SyndicationPerson_put_Uri), nullptr, nullptr },
        { "name", reinterpret_cast<getter>(SyndicationPerson_get_Name), reinterpret_cast<setter>(SyndicationPerson_put_Name), nullptr, nullptr },
        { "email", reinterpret_cast<getter>(SyndicationPerson_get_Email), reinterpret_cast<setter>(SyndicationPerson_put_Email), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationPerson[] = 
    {
        { Py_tp_new, _new_SyndicationPerson },
        { Py_tp_dealloc, _dealloc_SyndicationPerson },
        { Py_tp_methods, _methods_SyndicationPerson },
        { Py_tp_getset, _getset_SyndicationPerson },
        { },
    };

    static PyType_Spec _type_spec_SyndicationPerson =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationPerson",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationPerson),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationPerson
    };

    // ----- SyndicationText class --------------------
    constexpr const char* const _type_name_SyndicationText = "SyndicationText";

    static PyObject* _new_SyndicationText(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                winrt::Windows::Web::Syndication::SyndicationText instance{ param0 };
                return py::wrap(instance, type);
            }
            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::Web::Syndication::SyndicationTextType>(args, 1);

                winrt::Windows::Web::Syndication::SyndicationText instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Web::Syndication::SyndicationText 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_SyndicationText(py::wrapper::Windows::Web::Syndication::SyndicationText* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* SyndicationText_GetXmlDocument(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* SyndicationText_get_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_NodeValue(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationText_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationText_get_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_NodeName(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationText_get_Language(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_Language(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationText_get_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_BaseUri(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationText_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationText_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SyndicationText_get_Xml(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Xml());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_Xml(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlDocument>(arg);

            self->obj.Xml(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationText_get_Type(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Type());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_Type(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Type(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SyndicationText_get_Text(py::wrapper::Windows::Web::Syndication::SyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SyndicationText_put_Text(py::wrapper::Windows::Web::Syndication::SyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_SyndicationText(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::Web::Syndication::SyndicationText>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SyndicationText[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(SyndicationText_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SyndicationText), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SyndicationText[] = {
        { "node_value", reinterpret_cast<getter>(SyndicationText_get_NodeValue), reinterpret_cast<setter>(SyndicationText_put_NodeValue), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(SyndicationText_get_NodeNamespace), reinterpret_cast<setter>(SyndicationText_put_NodeNamespace), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(SyndicationText_get_NodeName), reinterpret_cast<setter>(SyndicationText_put_NodeName), nullptr, nullptr },
        { "language", reinterpret_cast<getter>(SyndicationText_get_Language), reinterpret_cast<setter>(SyndicationText_put_Language), nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(SyndicationText_get_BaseUri), reinterpret_cast<setter>(SyndicationText_put_BaseUri), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(SyndicationText_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(SyndicationText_get_ElementExtensions), nullptr, nullptr, nullptr },
        { "xml", reinterpret_cast<getter>(SyndicationText_get_Xml), reinterpret_cast<setter>(SyndicationText_put_Xml), nullptr, nullptr },
        { "type", reinterpret_cast<getter>(SyndicationText_get_Type), reinterpret_cast<setter>(SyndicationText_put_Type), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(SyndicationText_get_Text), reinterpret_cast<setter>(SyndicationText_put_Text), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SyndicationText[] = 
    {
        { Py_tp_new, _new_SyndicationText },
        { Py_tp_dealloc, _dealloc_SyndicationText },
        { Py_tp_methods, _methods_SyndicationText },
        { Py_tp_getset, _getset_SyndicationText },
        { },
    };

    static PyType_Spec _type_spec_SyndicationText =
    {
        "_winsdk_Windows_Web_Syndication.SyndicationText",
        sizeof(py::wrapper::Windows::Web::Syndication::SyndicationText),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SyndicationText
    };

    // ----- ISyndicationClient interface --------------------
    constexpr const char* const _type_name_ISyndicationClient = "ISyndicationClient";

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

    static void _dealloc_ISyndicationClient(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* ISyndicationClient_RetrieveFeedAsync(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* ISyndicationClient_SetRequestHeader(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* ISyndicationClient_get_BypassCacheOnRetrieve(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BypassCacheOnRetrieve());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationClient_put_BypassCacheOnRetrieve(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<bool>(arg);

            self->obj.BypassCacheOnRetrieve(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationClient_get_MaxResponseBufferSize(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.MaxResponseBufferSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationClient_put_MaxResponseBufferSize(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<uint32_t>(arg);

            self->obj.MaxResponseBufferSize(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationClient_get_ProxyCredential(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProxyCredential());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationClient_put_ProxyCredential(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Security::Credentials::PasswordCredential>(arg);

            self->obj.ProxyCredential(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationClient_get_ServerCredential(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ServerCredential());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationClient_put_ServerCredential(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Security::Credentials::PasswordCredential>(arg);

            self->obj.ServerCredential(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationClient_get_Timeout(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Timeout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationClient_put_Timeout(py::wrapper::Windows::Web::Syndication::ISyndicationClient* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<uint32_t>(arg);

            self->obj.Timeout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_ISyndicationClient(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::Web::Syndication::ISyndicationClient>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ISyndicationClient[] = {
        { "retrieve_feed_async", reinterpret_cast<PyCFunction>(ISyndicationClient_RetrieveFeedAsync), METH_VARARGS, nullptr },
        { "set_request_header", reinterpret_cast<PyCFunction>(ISyndicationClient_SetRequestHeader), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ISyndicationClient), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ISyndicationClient[] = {
        { "bypass_cache_on_retrieve", reinterpret_cast<getter>(ISyndicationClient_get_BypassCacheOnRetrieve), reinterpret_cast<setter>(ISyndicationClient_put_BypassCacheOnRetrieve), nullptr, nullptr },
        { "max_response_buffer_size", reinterpret_cast<getter>(ISyndicationClient_get_MaxResponseBufferSize), reinterpret_cast<setter>(ISyndicationClient_put_MaxResponseBufferSize), nullptr, nullptr },
        { "proxy_credential", reinterpret_cast<getter>(ISyndicationClient_get_ProxyCredential), reinterpret_cast<setter>(ISyndicationClient_put_ProxyCredential), nullptr, nullptr },
        { "server_credential", reinterpret_cast<getter>(ISyndicationClient_get_ServerCredential), reinterpret_cast<setter>(ISyndicationClient_put_ServerCredential), nullptr, nullptr },
        { "timeout", reinterpret_cast<getter>(ISyndicationClient_get_Timeout), reinterpret_cast<setter>(ISyndicationClient_put_Timeout), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ISyndicationClient[] = 
    {
        { Py_tp_new, _new_ISyndicationClient },
        { Py_tp_dealloc, _dealloc_ISyndicationClient },
        { Py_tp_methods, _methods_ISyndicationClient },
        { Py_tp_getset, _getset_ISyndicationClient },
        { },
    };

    static PyType_Spec _type_spec_ISyndicationClient =
    {
        "_winsdk_Windows_Web_Syndication.ISyndicationClient",
        sizeof(py::wrapper::Windows::Web::Syndication::ISyndicationClient),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ISyndicationClient
    };

    // ----- ISyndicationNode interface --------------------
    constexpr const char* const _type_name_ISyndicationNode = "ISyndicationNode";

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

    static void _dealloc_ISyndicationNode(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* ISyndicationNode_GetXmlDocument(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* ISyndicationNode_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ISyndicationNode_get_BaseUri(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationNode_put_BaseUri(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationNode_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ISyndicationNode_get_Language(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationNode_put_Language(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationNode_get_NodeName(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationNode_put_NodeName(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationNode_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationNode_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationNode_get_NodeValue(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationNode_put_NodeValue(py::wrapper::Windows::Web::Syndication::ISyndicationNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_ISyndicationNode(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::Web::Syndication::ISyndicationNode>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ISyndicationNode[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(ISyndicationNode_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ISyndicationNode), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ISyndicationNode[] = {
        { "attribute_extensions", reinterpret_cast<getter>(ISyndicationNode_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(ISyndicationNode_get_BaseUri), reinterpret_cast<setter>(ISyndicationNode_put_BaseUri), nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(ISyndicationNode_get_ElementExtensions), nullptr, nullptr, nullptr },
        { "language", reinterpret_cast<getter>(ISyndicationNode_get_Language), reinterpret_cast<setter>(ISyndicationNode_put_Language), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(ISyndicationNode_get_NodeName), reinterpret_cast<setter>(ISyndicationNode_put_NodeName), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(ISyndicationNode_get_NodeNamespace), reinterpret_cast<setter>(ISyndicationNode_put_NodeNamespace), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(ISyndicationNode_get_NodeValue), reinterpret_cast<setter>(ISyndicationNode_put_NodeValue), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ISyndicationNode[] = 
    {
        { Py_tp_new, _new_ISyndicationNode },
        { Py_tp_dealloc, _dealloc_ISyndicationNode },
        { Py_tp_methods, _methods_ISyndicationNode },
        { Py_tp_getset, _getset_ISyndicationNode },
        { },
    };

    static PyType_Spec _type_spec_ISyndicationNode =
    {
        "_winsdk_Windows_Web_Syndication.ISyndicationNode",
        sizeof(py::wrapper::Windows::Web::Syndication::ISyndicationNode),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ISyndicationNode
    };

    // ----- ISyndicationText interface --------------------
    constexpr const char* const _type_name_ISyndicationText = "ISyndicationText";

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

    static void _dealloc_ISyndicationText(py::wrapper::Windows::Web::Syndication::ISyndicationText* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* ISyndicationText_GetXmlDocument(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* ISyndicationText_get_Text(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_Text(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationText_get_Type(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Type());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_Type(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Type(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationText_get_Xml(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Xml());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_Xml(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlDocument>(arg);

            self->obj.Xml(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationText_get_AttributeExtensions(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AttributeExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ISyndicationText_get_BaseUri(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BaseUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_BaseUri(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(arg);

            self->obj.BaseUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationText_get_ElementExtensions(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ISyndicationText_get_Language(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Language());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_Language(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.Language(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationText_get_NodeName(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_NodeName(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationText_get_NodeNamespace(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeNamespace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_NodeNamespace(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeNamespace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISyndicationText_get_NodeValue(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISyndicationText_put_NodeValue(py::wrapper::Windows::Web::Syndication::ISyndicationText* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::hstring>(arg);

            self->obj.NodeValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_ISyndicationText(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::Web::Syndication::ISyndicationText>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ISyndicationText[] = {
        { "get_xml_document", reinterpret_cast<PyCFunction>(ISyndicationText_GetXmlDocument), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ISyndicationText), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ISyndicationText[] = {
        { "text", reinterpret_cast<getter>(ISyndicationText_get_Text), reinterpret_cast<setter>(ISyndicationText_put_Text), nullptr, nullptr },
        { "type", reinterpret_cast<getter>(ISyndicationText_get_Type), reinterpret_cast<setter>(ISyndicationText_put_Type), nullptr, nullptr },
        { "xml", reinterpret_cast<getter>(ISyndicationText_get_Xml), reinterpret_cast<setter>(ISyndicationText_put_Xml), nullptr, nullptr },
        { "attribute_extensions", reinterpret_cast<getter>(ISyndicationText_get_AttributeExtensions), nullptr, nullptr, nullptr },
        { "base_uri", reinterpret_cast<getter>(ISyndicationText_get_BaseUri), reinterpret_cast<setter>(ISyndicationText_put_BaseUri), nullptr, nullptr },
        { "element_extensions", reinterpret_cast<getter>(ISyndicationText_get_ElementExtensions), nullptr, nullptr, nullptr },
        { "language", reinterpret_cast<getter>(ISyndicationText_get_Language), reinterpret_cast<setter>(ISyndicationText_put_Language), nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(ISyndicationText_get_NodeName), reinterpret_cast<setter>(ISyndicationText_put_NodeName), nullptr, nullptr },
        { "node_namespace", reinterpret_cast<getter>(ISyndicationText_get_NodeNamespace), reinterpret_cast<setter>(ISyndicationText_put_NodeNamespace), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(ISyndicationText_get_NodeValue), reinterpret_cast<setter>(ISyndicationText_put_NodeValue), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ISyndicationText[] = 
    {
        { Py_tp_new, _new_ISyndicationText },
        { Py_tp_dealloc, _dealloc_ISyndicationText },
        { Py_tp_methods, _methods_ISyndicationText },
        { Py_tp_getset, _getset_ISyndicationText },
        { },
    };

    static PyType_Spec _type_spec_ISyndicationText =
    {
        "_winsdk_Windows_Web_Syndication.ISyndicationText",
        sizeof(py::wrapper::Windows::Web::Syndication::ISyndicationText),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ISyndicationText
    };

    // ----- RetrievalProgress struct --------------------
    constexpr const char* const _type_name_RetrievalProgress = "RetrievalProgress";

    PyObject* _new_RetrievalProgress(PyTypeObject* type, PyObject* args, PyObject* kwds)
    {
        auto tuple_size = PyTuple_Size(args);

        if ((tuple_size == 0) && (kwds == nullptr))
        {
            try
            {
                winrt::Windows::Web::Syndication::RetrievalProgress return_value{};
                return py::convert(return_value);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }

        if ((tuple_size == 1) && (kwds == nullptr))
        {
            auto arg = PyTuple_GetItem(args, 0);
            if (PyDict_Check(arg))
            {
                try
                {
                    auto return_value = py::convert_to<winrt::Windows::Web::Syndication::RetrievalProgress>(arg);
                    return py::convert(return_value);
                }
                catch (...)
                {
                    py::to_PyErr();
                    return nullptr;
                }
            }
        }

        uint32_t _BytesRetrieved{};
        uint32_t _TotalBytesToRetrieve{};

        static const char* kwlist[] = {"bytes_retrieved", "total_bytes_to_retrieve", nullptr};
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "II", const_cast<char**>(kwlist), &_BytesRetrieved, &_TotalBytesToRetrieve))
        {
            return nullptr;
        }

        try
        {
            winrt::Windows::Web::Syndication::RetrievalProgress return_value{ _BytesRetrieved, _TotalBytesToRetrieve };
            return py::convert(return_value);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static void _dealloc_RetrievalProgress(py::wrapper::Windows::Web::Syndication::RetrievalProgress* self)
    {
    }

    static PyObject* RetrievalProgress_get_BytesRetrieved(py::wrapper::Windows::Web::Syndication::RetrievalProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BytesRetrieved);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RetrievalProgress_set_BytesRetrieved(py::wrapper::Windows::Web::Syndication::RetrievalProgress* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            self->obj.BytesRetrieved = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RetrievalProgress_get_TotalBytesToRetrieve(py::wrapper::Windows::Web::Syndication::RetrievalProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.TotalBytesToRetrieve);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RetrievalProgress_set_TotalBytesToRetrieve(py::wrapper::Windows::Web::Syndication::RetrievalProgress* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            self->obj.TotalBytesToRetrieve = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyGetSetDef _getset_RetrievalProgress[] = {
        { "bytes_retrieved", reinterpret_cast<getter>(RetrievalProgress_get_BytesRetrieved), reinterpret_cast<setter>(RetrievalProgress_set_BytesRetrieved), nullptr, nullptr },
        { "total_bytes_to_retrieve", reinterpret_cast<getter>(RetrievalProgress_get_TotalBytesToRetrieve), reinterpret_cast<setter>(RetrievalProgress_set_TotalBytesToRetrieve), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RetrievalProgress[] = 
    {
        { Py_tp_new, _new_RetrievalProgress },
        { Py_tp_dealloc, _dealloc_RetrievalProgress },
        { Py_tp_getset, _getset_RetrievalProgress },
        { },
    };

    static PyType_Spec _type_spec_RetrievalProgress =
    {
        "_winsdk_Windows_Web_Syndication.RetrievalProgress",
        sizeof(py::wrapper::Windows::Web::Syndication::RetrievalProgress),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RetrievalProgress
    };

    // ----- TransferProgress struct --------------------
    constexpr const char* const _type_name_TransferProgress = "TransferProgress";

    PyObject* _new_TransferProgress(PyTypeObject* type, PyObject* args, PyObject* kwds)
    {
        auto tuple_size = PyTuple_Size(args);

        if ((tuple_size == 0) && (kwds == nullptr))
        {
            try
            {
                winrt::Windows::Web::Syndication::TransferProgress return_value{};
                return py::convert(return_value);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }

        if ((tuple_size == 1) && (kwds == nullptr))
        {
            auto arg = PyTuple_GetItem(args, 0);
            if (PyDict_Check(arg))
            {
                try
                {
                    auto return_value = py::convert_to<winrt::Windows::Web::Syndication::TransferProgress>(arg);
                    return py::convert(return_value);
                }
                catch (...)
                {
                    py::to_PyErr();
                    return nullptr;
                }
            }
        }

        uint32_t _BytesSent{};
        uint32_t _TotalBytesToSend{};
        uint32_t _BytesRetrieved{};
        uint32_t _TotalBytesToRetrieve{};

        static const char* kwlist[] = {"bytes_sent", "total_bytes_to_send", "bytes_retrieved", "total_bytes_to_retrieve", nullptr};
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "IIII", const_cast<char**>(kwlist), &_BytesSent, &_TotalBytesToSend, &_BytesRetrieved, &_TotalBytesToRetrieve))
        {
            return nullptr;
        }

        try
        {
            winrt::Windows::Web::Syndication::TransferProgress return_value{ _BytesSent, _TotalBytesToSend, _BytesRetrieved, _TotalBytesToRetrieve };
            return py::convert(return_value);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static void _dealloc_TransferProgress(py::wrapper::Windows::Web::Syndication::TransferProgress* self)
    {
    }

    static PyObject* TransferProgress_get_BytesSent(py::wrapper::Windows::Web::Syndication::TransferProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BytesSent);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TransferProgress_set_BytesSent(py::wrapper::Windows::Web::Syndication::TransferProgress* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            self->obj.BytesSent = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TransferProgress_get_TotalBytesToSend(py::wrapper::Windows::Web::Syndication::TransferProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.TotalBytesToSend);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TransferProgress_set_TotalBytesToSend(py::wrapper::Windows::Web::Syndication::TransferProgress* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            self->obj.TotalBytesToSend = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TransferProgress_get_BytesRetrieved(py::wrapper::Windows::Web::Syndication::TransferProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.BytesRetrieved);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TransferProgress_set_BytesRetrieved(py::wrapper::Windows::Web::Syndication::TransferProgress* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            self->obj.BytesRetrieved = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TransferProgress_get_TotalBytesToRetrieve(py::wrapper::Windows::Web::Syndication::TransferProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.TotalBytesToRetrieve);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TransferProgress_set_TotalBytesToRetrieve(py::wrapper::Windows::Web::Syndication::TransferProgress* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            self->obj.TotalBytesToRetrieve = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyGetSetDef _getset_TransferProgress[] = {
        { "bytes_sent", reinterpret_cast<getter>(TransferProgress_get_BytesSent), reinterpret_cast<setter>(TransferProgress_set_BytesSent), nullptr, nullptr },
        { "total_bytes_to_send", reinterpret_cast<getter>(TransferProgress_get_TotalBytesToSend), reinterpret_cast<setter>(TransferProgress_set_TotalBytesToSend), nullptr, nullptr },
        { "bytes_retrieved", reinterpret_cast<getter>(TransferProgress_get_BytesRetrieved), reinterpret_cast<setter>(TransferProgress_set_BytesRetrieved), nullptr, nullptr },
        { "total_bytes_to_retrieve", reinterpret_cast<getter>(TransferProgress_get_TotalBytesToRetrieve), reinterpret_cast<setter>(TransferProgress_set_TotalBytesToRetrieve), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TransferProgress[] = 
    {
        { Py_tp_new, _new_TransferProgress },
        { Py_tp_dealloc, _dealloc_TransferProgress },
        { Py_tp_getset, _getset_TransferProgress },
        { },
    };

    static PyType_Spec _type_spec_TransferProgress =
    {
        "_winsdk_Windows_Web_Syndication.TransferProgress",
        sizeof(py::wrapper::Windows::Web::Syndication::TransferProgress),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TransferProgress
    };

    // ----- Windows.Web.Syndication 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::Web::Syndication::SyndicationAttribute>::python_type = py::register_python_type(module, _type_name_SyndicationAttribute, &_type_spec_SyndicationAttribute, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationCategory>::python_type = py::register_python_type(module, _type_name_SyndicationCategory, &_type_spec_SyndicationCategory, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationClient>::python_type = py::register_python_type(module, _type_name_SyndicationClient, &_type_spec_SyndicationClient, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationContent>::python_type = py::register_python_type(module, _type_name_SyndicationContent, &_type_spec_SyndicationContent, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationError>::python_type = py::register_python_type(module, _type_name_SyndicationError, &_type_spec_SyndicationError, nullptr);
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationFeed>::python_type = py::register_python_type(module, _type_name_SyndicationFeed, &_type_spec_SyndicationFeed, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationGenerator>::python_type = py::register_python_type(module, _type_name_SyndicationGenerator, &_type_spec_SyndicationGenerator, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationItem>::python_type = py::register_python_type(module, _type_name_SyndicationItem, &_type_spec_SyndicationItem, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationLink>::python_type = py::register_python_type(module, _type_name_SyndicationLink, &_type_spec_SyndicationLink, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationNode>::python_type = py::register_python_type(module, _type_name_SyndicationNode, &_type_spec_SyndicationNode, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationPerson>::python_type = py::register_python_type(module, _type_name_SyndicationPerson, &_type_spec_SyndicationPerson, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::SyndicationText>::python_type = py::register_python_type(module, _type_name_SyndicationText, &_type_spec_SyndicationText, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::ISyndicationClient>::python_type = py::register_python_type(module, _type_name_ISyndicationClient, &_type_spec_ISyndicationClient, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::ISyndicationNode>::python_type = py::register_python_type(module, _type_name_ISyndicationNode, &_type_spec_ISyndicationNode, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::ISyndicationText>::python_type = py::register_python_type(module, _type_name_ISyndicationText, &_type_spec_ISyndicationText, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::RetrievalProgress>::python_type = py::register_python_type(module, _type_name_RetrievalProgress, &_type_spec_RetrievalProgress, bases.get());
            py::winrt_type<winrt::Windows::Web::Syndication::TransferProgress>::python_type = py::register_python_type(module, _type_name_TransferProgress, &_type_spec_TransferProgress, 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.Web.Syndication");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Web_Syndication",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::Web::Syndication

PyMODINIT_FUNC
PyInit__winsdk_Windows_Web_Syndication (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Web::Syndication::module_def);
}
