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

#include "pybase.h"
#include "py.Windows.Data.Xml.Dom.h"

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::DtdEntity>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::DtdNotation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlAttribute>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlCDataSection>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlComment>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocument>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocumentFragment>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocumentType>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDomImplementation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlElement>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlEntityReference>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlLoadSettings>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlNamedNodeMap>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlNodeList>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlProcessingInstruction>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlText>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlCharacterData>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNode>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNodeSelector>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNodeSerializer>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlText>::python_type;

namespace py::cpp::Windows::Data::Xml::Dom
{
    // ----- DtdEntity class --------------------
    constexpr const char* const _type_name_DtdEntity = "DtdEntity";

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

    static void _dealloc_DtdEntity(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* DtdEntity_AppendChild(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* 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::IXmlNode>(args, 0);

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

    static PyObject* DtdEntity_CloneNode(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdEntity_GetXml(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* DtdEntity_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* DtdEntity_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdEntity_Normalize(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* DtdEntity_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* 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::IXmlNode>(args, 0);

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

    static PyObject* DtdEntity_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdEntity_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdEntity_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* DtdEntity_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdEntity_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* DtdEntity_get_NotationName(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NotationName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_PublicId(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PublicId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_SystemId(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SystemId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int DtdEntity_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* 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::IInspectable>(arg);

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

    static PyObject* DtdEntity_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int DtdEntity_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* 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::IInspectable>(arg);

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

    static PyObject* DtdEntity_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdEntity_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int DtdEntity_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::DtdEntity* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_DtdEntity(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::Data::Xml::Dom::DtdEntity>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DtdEntity[] = {
        { "append_child", reinterpret_cast<PyCFunction>(DtdEntity_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(DtdEntity_CloneNode), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(DtdEntity_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(DtdEntity_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(DtdEntity_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(DtdEntity_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(DtdEntity_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(DtdEntity_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(DtdEntity_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(DtdEntity_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(DtdEntity_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(DtdEntity_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DtdEntity), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DtdEntity[] = {
        { "notation_name", reinterpret_cast<getter>(DtdEntity_get_NotationName), nullptr, nullptr, nullptr },
        { "public_id", reinterpret_cast<getter>(DtdEntity_get_PublicId), nullptr, nullptr, nullptr },
        { "system_id", reinterpret_cast<getter>(DtdEntity_get_SystemId), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(DtdEntity_get_Prefix), reinterpret_cast<setter>(DtdEntity_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(DtdEntity_get_NodeValue), reinterpret_cast<setter>(DtdEntity_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(DtdEntity_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(DtdEntity_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(DtdEntity_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(DtdEntity_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(DtdEntity_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(DtdEntity_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(DtdEntity_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(DtdEntity_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(DtdEntity_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(DtdEntity_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(DtdEntity_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(DtdEntity_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(DtdEntity_get_InnerText), reinterpret_cast<setter>(DtdEntity_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DtdEntity[] = 
    {
        { Py_tp_new, _new_DtdEntity },
        { Py_tp_dealloc, _dealloc_DtdEntity },
        { Py_tp_methods, _methods_DtdEntity },
        { Py_tp_getset, _getset_DtdEntity },
        { },
    };

    static PyType_Spec _type_spec_DtdEntity =
    {
        "_winsdk_Windows_Data_Xml_Dom.DtdEntity",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::DtdEntity),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DtdEntity
    };

    // ----- DtdNotation class --------------------
    constexpr const char* const _type_name_DtdNotation = "DtdNotation";

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

    static void _dealloc_DtdNotation(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* DtdNotation_AppendChild(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* 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::IXmlNode>(args, 0);

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

    static PyObject* DtdNotation_CloneNode(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdNotation_GetXml(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* DtdNotation_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* DtdNotation_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdNotation_Normalize(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* DtdNotation_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* 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::IXmlNode>(args, 0);

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

    static PyObject* DtdNotation_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdNotation_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdNotation_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* DtdNotation_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* DtdNotation_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* DtdNotation_get_PublicId(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PublicId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_SystemId(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SystemId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int DtdNotation_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* 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::IInspectable>(arg);

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

    static PyObject* DtdNotation_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int DtdNotation_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* 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::IInspectable>(arg);

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

    static PyObject* DtdNotation_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DtdNotation_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int DtdNotation_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::DtdNotation* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_DtdNotation(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::Data::Xml::Dom::DtdNotation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DtdNotation[] = {
        { "append_child", reinterpret_cast<PyCFunction>(DtdNotation_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(DtdNotation_CloneNode), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(DtdNotation_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(DtdNotation_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(DtdNotation_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(DtdNotation_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(DtdNotation_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(DtdNotation_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(DtdNotation_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(DtdNotation_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(DtdNotation_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(DtdNotation_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DtdNotation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DtdNotation[] = {
        { "public_id", reinterpret_cast<getter>(DtdNotation_get_PublicId), nullptr, nullptr, nullptr },
        { "system_id", reinterpret_cast<getter>(DtdNotation_get_SystemId), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(DtdNotation_get_Prefix), reinterpret_cast<setter>(DtdNotation_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(DtdNotation_get_NodeValue), reinterpret_cast<setter>(DtdNotation_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(DtdNotation_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(DtdNotation_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(DtdNotation_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(DtdNotation_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(DtdNotation_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(DtdNotation_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(DtdNotation_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(DtdNotation_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(DtdNotation_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(DtdNotation_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(DtdNotation_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(DtdNotation_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(DtdNotation_get_InnerText), reinterpret_cast<setter>(DtdNotation_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DtdNotation[] = 
    {
        { Py_tp_new, _new_DtdNotation },
        { Py_tp_dealloc, _dealloc_DtdNotation },
        { Py_tp_methods, _methods_DtdNotation },
        { Py_tp_getset, _getset_DtdNotation },
        { },
    };

    static PyType_Spec _type_spec_DtdNotation =
    {
        "_winsdk_Windows_Data_Xml_Dom.DtdNotation",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::DtdNotation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DtdNotation
    };

    // ----- XmlAttribute class --------------------
    constexpr const char* const _type_name_XmlAttribute = "XmlAttribute";

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

    static void _dealloc_XmlAttribute(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlAttribute_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlAttribute_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlAttribute_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlAttribute_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlAttribute_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlAttribute_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlAttribute_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlAttribute_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlAttribute_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlAttribute_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlAttribute_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlAttribute_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlAttribute_get_Value(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Value());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlAttribute_put_Value(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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* XmlAttribute_get_Specified(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Specified());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_Name(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlAttribute_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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::IInspectable>(arg);

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

    static PyObject* XmlAttribute_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlAttribute_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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::IInspectable>(arg);

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

    static PyObject* XmlAttribute_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlAttribute_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlAttribute_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlAttribute(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::Data::Xml::Dom::XmlAttribute>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlAttribute[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlAttribute_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlAttribute_CloneNode), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlAttribute_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlAttribute_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlAttribute_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlAttribute_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlAttribute_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlAttribute_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlAttribute_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlAttribute_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlAttribute_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlAttribute_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlAttribute), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlAttribute[] = {
        { "value", reinterpret_cast<getter>(XmlAttribute_get_Value), reinterpret_cast<setter>(XmlAttribute_put_Value), nullptr, nullptr },
        { "specified", reinterpret_cast<getter>(XmlAttribute_get_Specified), nullptr, nullptr, nullptr },
        { "name", reinterpret_cast<getter>(XmlAttribute_get_Name), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(XmlAttribute_get_Prefix), reinterpret_cast<setter>(XmlAttribute_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlAttribute_get_NodeValue), reinterpret_cast<setter>(XmlAttribute_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlAttribute_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlAttribute_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlAttribute_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlAttribute_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlAttribute_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlAttribute_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlAttribute_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlAttribute_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlAttribute_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlAttribute_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlAttribute_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlAttribute_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlAttribute_get_InnerText), reinterpret_cast<setter>(XmlAttribute_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlAttribute[] = 
    {
        { Py_tp_new, _new_XmlAttribute },
        { Py_tp_dealloc, _dealloc_XmlAttribute },
        { Py_tp_methods, _methods_XmlAttribute },
        { Py_tp_getset, _getset_XmlAttribute },
        { },
    };

    static PyType_Spec _type_spec_XmlAttribute =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlAttribute",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlAttribute),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlAttribute
    };

    // ----- XmlCDataSection class --------------------
    constexpr const char* const _type_name_XmlCDataSection = "XmlCDataSection";

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

    static void _dealloc_XmlCDataSection(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlCDataSection_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlCDataSection_AppendData(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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.AppendData(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_DeleteData(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlCDataSection_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlCDataSection_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_InsertData(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlCDataSection_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlCDataSection_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_ReplaceData(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlCDataSection_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlCDataSection_SplitText(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_SubstringData(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlCDataSection_get_Data(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlCDataSection_put_Data(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlCDataSection_get_Length(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlCDataSection_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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::IInspectable>(arg);

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

    static PyObject* XmlCDataSection_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlCDataSection_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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::IInspectable>(arg);

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

    static PyObject* XmlCDataSection_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlCDataSection_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlCDataSection_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlCDataSection(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::Data::Xml::Dom::XmlCDataSection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlCDataSection[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlCDataSection_AppendChild), METH_VARARGS, nullptr },
        { "append_data", reinterpret_cast<PyCFunction>(XmlCDataSection_AppendData), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlCDataSection_CloneNode), METH_VARARGS, nullptr },
        { "delete_data", reinterpret_cast<PyCFunction>(XmlCDataSection_DeleteData), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlCDataSection_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlCDataSection_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlCDataSection_InsertBefore), METH_VARARGS, nullptr },
        { "insert_data", reinterpret_cast<PyCFunction>(XmlCDataSection_InsertData), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlCDataSection_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlCDataSection_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlCDataSection_ReplaceChild), METH_VARARGS, nullptr },
        { "replace_data", reinterpret_cast<PyCFunction>(XmlCDataSection_ReplaceData), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlCDataSection_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlCDataSection_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlCDataSection_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlCDataSection_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "split_text", reinterpret_cast<PyCFunction>(XmlCDataSection_SplitText), METH_VARARGS, nullptr },
        { "substring_data", reinterpret_cast<PyCFunction>(XmlCDataSection_SubstringData), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlCDataSection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlCDataSection[] = {
        { "data", reinterpret_cast<getter>(XmlCDataSection_get_Data), reinterpret_cast<setter>(XmlCDataSection_put_Data), nullptr, nullptr },
        { "length", reinterpret_cast<getter>(XmlCDataSection_get_Length), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(XmlCDataSection_get_Prefix), reinterpret_cast<setter>(XmlCDataSection_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlCDataSection_get_NodeValue), reinterpret_cast<setter>(XmlCDataSection_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlCDataSection_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlCDataSection_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlCDataSection_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlCDataSection_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlCDataSection_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlCDataSection_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlCDataSection_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlCDataSection_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlCDataSection_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlCDataSection_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlCDataSection_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlCDataSection_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlCDataSection_get_InnerText), reinterpret_cast<setter>(XmlCDataSection_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlCDataSection[] = 
    {
        { Py_tp_new, _new_XmlCDataSection },
        { Py_tp_dealloc, _dealloc_XmlCDataSection },
        { Py_tp_methods, _methods_XmlCDataSection },
        { Py_tp_getset, _getset_XmlCDataSection },
        { },
    };

    static PyType_Spec _type_spec_XmlCDataSection =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlCDataSection",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlCDataSection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlCDataSection
    };

    // ----- XmlComment class --------------------
    constexpr const char* const _type_name_XmlComment = "XmlComment";

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

    static void _dealloc_XmlComment(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlComment_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlComment_AppendData(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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.AppendData(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlComment_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_DeleteData(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlComment_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlComment_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_InsertData(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlComment_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlComment_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_ReplaceData(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlComment_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlComment_SubstringData(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlComment_get_Data(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlComment_put_Data(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlComment_get_Length(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlComment_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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::IInspectable>(arg);

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

    static PyObject* XmlComment_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlComment_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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::IInspectable>(arg);

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

    static PyObject* XmlComment_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlComment_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlComment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlComment_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlComment* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlComment(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::Data::Xml::Dom::XmlComment>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlComment[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlComment_AppendChild), METH_VARARGS, nullptr },
        { "append_data", reinterpret_cast<PyCFunction>(XmlComment_AppendData), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlComment_CloneNode), METH_VARARGS, nullptr },
        { "delete_data", reinterpret_cast<PyCFunction>(XmlComment_DeleteData), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlComment_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlComment_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlComment_InsertBefore), METH_VARARGS, nullptr },
        { "insert_data", reinterpret_cast<PyCFunction>(XmlComment_InsertData), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlComment_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlComment_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlComment_ReplaceChild), METH_VARARGS, nullptr },
        { "replace_data", reinterpret_cast<PyCFunction>(XmlComment_ReplaceData), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlComment_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlComment_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlComment_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlComment_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "substring_data", reinterpret_cast<PyCFunction>(XmlComment_SubstringData), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlComment), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlComment[] = {
        { "data", reinterpret_cast<getter>(XmlComment_get_Data), reinterpret_cast<setter>(XmlComment_put_Data), nullptr, nullptr },
        { "length", reinterpret_cast<getter>(XmlComment_get_Length), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(XmlComment_get_Prefix), reinterpret_cast<setter>(XmlComment_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlComment_get_NodeValue), reinterpret_cast<setter>(XmlComment_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlComment_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlComment_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlComment_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlComment_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlComment_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlComment_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlComment_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlComment_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlComment_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlComment_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlComment_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlComment_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlComment_get_InnerText), reinterpret_cast<setter>(XmlComment_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlComment[] = 
    {
        { Py_tp_new, _new_XmlComment },
        { Py_tp_dealloc, _dealloc_XmlComment },
        { Py_tp_methods, _methods_XmlComment },
        { Py_tp_getset, _getset_XmlComment },
        { },
    };

    static PyType_Spec _type_spec_XmlComment =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlComment",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlComment),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlComment
    };

    // ----- XmlDocument class --------------------
    constexpr const char* const _type_name_XmlDocument = "XmlDocument";

    static PyObject* _new_XmlDocument(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 == 0)
        {
            try
            {
                winrt::Windows::Data::Xml::Dom::XmlDocument 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_XmlDocument(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlDocument_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlDocument_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateAttribute(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateAttributeNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateCDataSection(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateComment(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateDocumentFragment(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocument_CreateElement(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateElementNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateEntityReference(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_CreateProcessingInstruction(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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);

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

    static PyObject* XmlDocument_CreateTextNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_GetElementById(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_GetElementsByTagName(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocument_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocument_ImportNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

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

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

                return py::convert(winrt::Windows::Data::Xml::Dom::XmlDocument::LoadFromFileAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::IStorageFile>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlLoadSettings>(args, 1);

                return py::convert(winrt::Windows::Data::Xml::Dom::XmlDocument::LoadFromFileAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlDocument_LoadFromUriAsync(PyObject* /*unused*/, 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(winrt::Windows::Data::Xml::Dom::XmlDocument::LoadFromUriAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Uri>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlLoadSettings>(args, 1);

                return py::convert(winrt::Windows::Data::Xml::Dom::XmlDocument::LoadFromUriAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlDocument_LoadXml(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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.LoadXml(param0);
                Py_RETURN_NONE;
            }
            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::Data::Xml::Dom::XmlLoadSettings>(args, 1);

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

    static PyObject* XmlDocument_LoadXmlFromBuffer(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                self->obj.LoadXmlFromBuffer(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlLoadSettings>(args, 1);

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

    static PyObject* XmlDocument_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocument_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlDocument_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_SaveToFileAsync(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlDocument_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocument_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlDocument_get_Doctype(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Doctype());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_DocumentElement(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DocumentElement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_DocumentUri(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DocumentUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_Implementation(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Implementation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocument_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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::IInspectable>(arg);

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

    static PyObject* XmlDocument_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocument_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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::IInspectable>(arg);

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

    static PyObject* XmlDocument_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocument_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocument_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlDocument* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlDocument(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::Data::Xml::Dom::XmlDocument>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlDocument[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlDocument_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlDocument_CloneNode), METH_VARARGS, nullptr },
        { "create_attribute", reinterpret_cast<PyCFunction>(XmlDocument_CreateAttribute), METH_VARARGS, nullptr },
        { "create_attribute_n_s", reinterpret_cast<PyCFunction>(XmlDocument_CreateAttributeNS), METH_VARARGS, nullptr },
        { "create_c_data_section", reinterpret_cast<PyCFunction>(XmlDocument_CreateCDataSection), METH_VARARGS, nullptr },
        { "create_comment", reinterpret_cast<PyCFunction>(XmlDocument_CreateComment), METH_VARARGS, nullptr },
        { "create_document_fragment", reinterpret_cast<PyCFunction>(XmlDocument_CreateDocumentFragment), METH_VARARGS, nullptr },
        { "create_element", reinterpret_cast<PyCFunction>(XmlDocument_CreateElement), METH_VARARGS, nullptr },
        { "create_element_n_s", reinterpret_cast<PyCFunction>(XmlDocument_CreateElementNS), METH_VARARGS, nullptr },
        { "create_entity_reference", reinterpret_cast<PyCFunction>(XmlDocument_CreateEntityReference), METH_VARARGS, nullptr },
        { "create_processing_instruction", reinterpret_cast<PyCFunction>(XmlDocument_CreateProcessingInstruction), METH_VARARGS, nullptr },
        { "create_text_node", reinterpret_cast<PyCFunction>(XmlDocument_CreateTextNode), METH_VARARGS, nullptr },
        { "get_element_by_id", reinterpret_cast<PyCFunction>(XmlDocument_GetElementById), METH_VARARGS, nullptr },
        { "get_elements_by_tag_name", reinterpret_cast<PyCFunction>(XmlDocument_GetElementsByTagName), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlDocument_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlDocument_HasChildNodes), METH_VARARGS, nullptr },
        { "import_node", reinterpret_cast<PyCFunction>(XmlDocument_ImportNode), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlDocument_InsertBefore), METH_VARARGS, nullptr },
        { "load_from_file_async", reinterpret_cast<PyCFunction>(XmlDocument_LoadFromFileAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_from_uri_async", reinterpret_cast<PyCFunction>(XmlDocument_LoadFromUriAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_xml", reinterpret_cast<PyCFunction>(XmlDocument_LoadXml), METH_VARARGS, nullptr },
        { "load_xml_from_buffer", reinterpret_cast<PyCFunction>(XmlDocument_LoadXmlFromBuffer), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlDocument_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlDocument_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlDocument_ReplaceChild), METH_VARARGS, nullptr },
        { "save_to_file_async", reinterpret_cast<PyCFunction>(XmlDocument_SaveToFileAsync), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlDocument_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlDocument_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlDocument_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlDocument_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlDocument), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlDocument[] = {
        { "doctype", reinterpret_cast<getter>(XmlDocument_get_Doctype), nullptr, nullptr, nullptr },
        { "document_element", reinterpret_cast<getter>(XmlDocument_get_DocumentElement), nullptr, nullptr, nullptr },
        { "document_uri", reinterpret_cast<getter>(XmlDocument_get_DocumentUri), nullptr, nullptr, nullptr },
        { "implementation", reinterpret_cast<getter>(XmlDocument_get_Implementation), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(XmlDocument_get_Prefix), reinterpret_cast<setter>(XmlDocument_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlDocument_get_NodeValue), reinterpret_cast<setter>(XmlDocument_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlDocument_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlDocument_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlDocument_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlDocument_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlDocument_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlDocument_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlDocument_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlDocument_get_Attributes), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlDocument_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlDocument_get_ParentNode), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlDocument_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlDocument_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlDocument_get_InnerText), reinterpret_cast<setter>(XmlDocument_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlDocument[] = 
    {
        { Py_tp_new, _new_XmlDocument },
        { Py_tp_dealloc, _dealloc_XmlDocument },
        { Py_tp_methods, _methods_XmlDocument },
        { Py_tp_getset, _getset_XmlDocument },
        { },
    };

    static PyType_Spec _type_spec_XmlDocument =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlDocument",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlDocument),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlDocument
    };

    // ----- XmlDocumentFragment class --------------------
    constexpr const char* const _type_name_XmlDocumentFragment = "XmlDocumentFragment";

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

    static void _dealloc_XmlDocumentFragment(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlDocumentFragment_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlDocumentFragment_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentFragment_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocumentFragment_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocumentFragment_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentFragment_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocumentFragment_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlDocumentFragment_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentFragment_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentFragment_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlDocumentFragment_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentFragment_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlDocumentFragment_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocumentFragment_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* 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::IInspectable>(arg);

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

    static PyObject* XmlDocumentFragment_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocumentFragment_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* 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::IInspectable>(arg);

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

    static PyObject* XmlDocumentFragment_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentFragment_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocumentFragment_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlDocumentFragment(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::Data::Xml::Dom::XmlDocumentFragment>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlDocumentFragment[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlDocumentFragment_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlDocumentFragment_CloneNode), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlDocumentFragment_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlDocumentFragment_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlDocumentFragment_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlDocumentFragment_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlDocumentFragment_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlDocumentFragment_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlDocumentFragment_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlDocumentFragment_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlDocumentFragment_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlDocumentFragment_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlDocumentFragment), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlDocumentFragment[] = {
        { "prefix", reinterpret_cast<getter>(XmlDocumentFragment_get_Prefix), reinterpret_cast<setter>(XmlDocumentFragment_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlDocumentFragment_get_NodeValue), reinterpret_cast<setter>(XmlDocumentFragment_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlDocumentFragment_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlDocumentFragment_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlDocumentFragment_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlDocumentFragment_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlDocumentFragment_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlDocumentFragment_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlDocumentFragment_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlDocumentFragment_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlDocumentFragment_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlDocumentFragment_get_ParentNode), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlDocumentFragment_get_ChildNodes), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlDocumentFragment_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlDocumentFragment_get_InnerText), reinterpret_cast<setter>(XmlDocumentFragment_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlDocumentFragment[] = 
    {
        { Py_tp_new, _new_XmlDocumentFragment },
        { Py_tp_dealloc, _dealloc_XmlDocumentFragment },
        { Py_tp_methods, _methods_XmlDocumentFragment },
        { Py_tp_getset, _getset_XmlDocumentFragment },
        { },
    };

    static PyType_Spec _type_spec_XmlDocumentFragment =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlDocumentFragment",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentFragment),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlDocumentFragment
    };

    // ----- XmlDocumentType class --------------------
    constexpr const char* const _type_name_XmlDocumentType = "XmlDocumentType";

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

    static void _dealloc_XmlDocumentType(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlDocumentType_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlDocumentType_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentType_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocumentType_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocumentType_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentType_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlDocumentType_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlDocumentType_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentType_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentType_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlDocumentType_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlDocumentType_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlDocumentType_get_Entities(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Entities());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_Name(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_Notations(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Notations());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocumentType_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* 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::IInspectable>(arg);

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

    static PyObject* XmlDocumentType_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocumentType_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* 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::IInspectable>(arg);

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

    static PyObject* XmlDocumentType_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlDocumentType_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlDocumentType_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlDocumentType(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::Data::Xml::Dom::XmlDocumentType>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlDocumentType[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlDocumentType_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlDocumentType_CloneNode), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlDocumentType_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlDocumentType_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlDocumentType_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlDocumentType_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlDocumentType_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlDocumentType_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlDocumentType_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlDocumentType_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlDocumentType_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlDocumentType_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlDocumentType), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlDocumentType[] = {
        { "entities", reinterpret_cast<getter>(XmlDocumentType_get_Entities), nullptr, nullptr, nullptr },
        { "name", reinterpret_cast<getter>(XmlDocumentType_get_Name), nullptr, nullptr, nullptr },
        { "notations", reinterpret_cast<getter>(XmlDocumentType_get_Notations), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(XmlDocumentType_get_Prefix), reinterpret_cast<setter>(XmlDocumentType_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlDocumentType_get_NodeValue), reinterpret_cast<setter>(XmlDocumentType_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlDocumentType_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlDocumentType_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlDocumentType_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlDocumentType_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlDocumentType_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlDocumentType_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlDocumentType_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlDocumentType_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlDocumentType_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlDocumentType_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlDocumentType_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlDocumentType_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlDocumentType_get_InnerText), reinterpret_cast<setter>(XmlDocumentType_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlDocumentType[] = 
    {
        { Py_tp_new, _new_XmlDocumentType },
        { Py_tp_dealloc, _dealloc_XmlDocumentType },
        { Py_tp_methods, _methods_XmlDocumentType },
        { Py_tp_getset, _getset_XmlDocumentType },
        { },
    };

    static PyType_Spec _type_spec_XmlDocumentType =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlDocumentType",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlDocumentType),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlDocumentType
    };

    // ----- XmlDomImplementation class --------------------
    constexpr const char* const _type_name_XmlDomImplementation = "XmlDomImplementation";

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

    static void _dealloc_XmlDomImplementation(py::wrapper::Windows::Data::Xml::Dom::XmlDomImplementation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlDomImplementation_HasFeature(py::wrapper::Windows::Data::Xml::Dom::XmlDomImplementation* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* _from_XmlDomImplementation(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::Data::Xml::Dom::XmlDomImplementation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlDomImplementation[] = {
        { "has_feature", reinterpret_cast<PyCFunction>(XmlDomImplementation_HasFeature), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlDomImplementation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlDomImplementation[] = {
        { }
    };

    static PyType_Slot _type_slots_XmlDomImplementation[] = 
    {
        { Py_tp_new, _new_XmlDomImplementation },
        { Py_tp_dealloc, _dealloc_XmlDomImplementation },
        { Py_tp_methods, _methods_XmlDomImplementation },
        { Py_tp_getset, _getset_XmlDomImplementation },
        { },
    };

    static PyType_Spec _type_spec_XmlDomImplementation =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlDomImplementation",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlDomImplementation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlDomImplementation
    };

    // ----- XmlElement class --------------------
    constexpr const char* const _type_name_XmlElement = "XmlElement";

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

    static void _dealloc_XmlElement(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlElement_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlElement_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_GetAttribute(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_GetAttributeNS(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_GetAttributeNode(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_GetAttributeNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_GetElementsByTagName(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlElement_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlElement_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlElement_RemoveAttribute(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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.RemoveAttribute(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlElement_RemoveAttributeNS(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_RemoveAttributeNode(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::XmlAttribute>(args, 0);

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

    static PyObject* XmlElement_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlElement_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlElement_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlElement_SetAttribute(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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.SetAttribute(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlElement_SetAttributeNS(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlElement_SetAttributeNode(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::XmlAttribute>(args, 0);

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

    static PyObject* XmlElement_SetAttributeNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::XmlAttribute>(args, 0);

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

    static PyObject* XmlElement_get_TagName(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.TagName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlElement_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::IInspectable>(arg);

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

    static PyObject* XmlElement_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlElement_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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::IInspectable>(arg);

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

    static PyObject* XmlElement_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlElement_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlElement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlElement_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlElement* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlElement(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::Data::Xml::Dom::XmlElement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlElement[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlElement_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlElement_CloneNode), METH_VARARGS, nullptr },
        { "get_attribute", reinterpret_cast<PyCFunction>(XmlElement_GetAttribute), METH_VARARGS, nullptr },
        { "get_attribute_n_s", reinterpret_cast<PyCFunction>(XmlElement_GetAttributeNS), METH_VARARGS, nullptr },
        { "get_attribute_node", reinterpret_cast<PyCFunction>(XmlElement_GetAttributeNode), METH_VARARGS, nullptr },
        { "get_attribute_node_n_s", reinterpret_cast<PyCFunction>(XmlElement_GetAttributeNodeNS), METH_VARARGS, nullptr },
        { "get_elements_by_tag_name", reinterpret_cast<PyCFunction>(XmlElement_GetElementsByTagName), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlElement_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlElement_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlElement_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlElement_Normalize), METH_VARARGS, nullptr },
        { "remove_attribute", reinterpret_cast<PyCFunction>(XmlElement_RemoveAttribute), METH_VARARGS, nullptr },
        { "remove_attribute_n_s", reinterpret_cast<PyCFunction>(XmlElement_RemoveAttributeNS), METH_VARARGS, nullptr },
        { "remove_attribute_node", reinterpret_cast<PyCFunction>(XmlElement_RemoveAttributeNode), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlElement_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlElement_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlElement_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlElement_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlElement_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlElement_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "set_attribute", reinterpret_cast<PyCFunction>(XmlElement_SetAttribute), METH_VARARGS, nullptr },
        { "set_attribute_n_s", reinterpret_cast<PyCFunction>(XmlElement_SetAttributeNS), METH_VARARGS, nullptr },
        { "set_attribute_node", reinterpret_cast<PyCFunction>(XmlElement_SetAttributeNode), METH_VARARGS, nullptr },
        { "set_attribute_node_n_s", reinterpret_cast<PyCFunction>(XmlElement_SetAttributeNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlElement), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlElement[] = {
        { "tag_name", reinterpret_cast<getter>(XmlElement_get_TagName), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(XmlElement_get_Prefix), reinterpret_cast<setter>(XmlElement_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlElement_get_NodeValue), reinterpret_cast<setter>(XmlElement_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlElement_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlElement_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlElement_get_LocalName), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlElement_get_NextSibling), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlElement_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlElement_get_NodeType), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlElement_get_NodeName), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlElement_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlElement_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlElement_get_ParentNode), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlElement_get_ChildNodes), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlElement_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlElement_get_InnerText), reinterpret_cast<setter>(XmlElement_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlElement[] = 
    {
        { Py_tp_new, _new_XmlElement },
        { Py_tp_dealloc, _dealloc_XmlElement },
        { Py_tp_methods, _methods_XmlElement },
        { Py_tp_getset, _getset_XmlElement },
        { },
    };

    static PyType_Spec _type_spec_XmlElement =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlElement",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlElement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlElement
    };

    // ----- XmlEntityReference class --------------------
    constexpr const char* const _type_name_XmlEntityReference = "XmlEntityReference";

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

    static void _dealloc_XmlEntityReference(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlEntityReference_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlEntityReference_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlEntityReference_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlEntityReference_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlEntityReference_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlEntityReference_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlEntityReference_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlEntityReference_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlEntityReference_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlEntityReference_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlEntityReference_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlEntityReference_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlEntityReference_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlEntityReference_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* 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::IInspectable>(arg);

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

    static PyObject* XmlEntityReference_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlEntityReference_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* 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::IInspectable>(arg);

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

    static PyObject* XmlEntityReference_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlEntityReference_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlEntityReference_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlEntityReference(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::Data::Xml::Dom::XmlEntityReference>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlEntityReference[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlEntityReference_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlEntityReference_CloneNode), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlEntityReference_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlEntityReference_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlEntityReference_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlEntityReference_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlEntityReference_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlEntityReference_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlEntityReference_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlEntityReference_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlEntityReference_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlEntityReference_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlEntityReference), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlEntityReference[] = {
        { "prefix", reinterpret_cast<getter>(XmlEntityReference_get_Prefix), reinterpret_cast<setter>(XmlEntityReference_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlEntityReference_get_NodeValue), reinterpret_cast<setter>(XmlEntityReference_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlEntityReference_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlEntityReference_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlEntityReference_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlEntityReference_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlEntityReference_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlEntityReference_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlEntityReference_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlEntityReference_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlEntityReference_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlEntityReference_get_ParentNode), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlEntityReference_get_ChildNodes), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlEntityReference_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlEntityReference_get_InnerText), reinterpret_cast<setter>(XmlEntityReference_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlEntityReference[] = 
    {
        { Py_tp_new, _new_XmlEntityReference },
        { Py_tp_dealloc, _dealloc_XmlEntityReference },
        { Py_tp_methods, _methods_XmlEntityReference },
        { Py_tp_getset, _getset_XmlEntityReference },
        { },
    };

    static PyType_Spec _type_spec_XmlEntityReference =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlEntityReference",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlEntityReference),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlEntityReference
    };

    // ----- XmlLoadSettings class --------------------
    constexpr const char* const _type_name_XmlLoadSettings = "XmlLoadSettings";

    static PyObject* _new_XmlLoadSettings(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 == 0)
        {
            try
            {
                winrt::Windows::Data::Xml::Dom::XmlLoadSettings 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_XmlLoadSettings(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlLoadSettings_get_ValidateOnParse(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ValidateOnParse());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlLoadSettings_put_ValidateOnParse(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* 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.ValidateOnParse(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlLoadSettings_get_ResolveExternals(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ResolveExternals());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlLoadSettings_put_ResolveExternals(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* 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.ResolveExternals(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlLoadSettings_get_ProhibitDtd(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProhibitDtd());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlLoadSettings_put_ProhibitDtd(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* 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.ProhibitDtd(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlLoadSettings_get_MaxElementDepth(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.MaxElementDepth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlLoadSettings_put_MaxElementDepth(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* 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.MaxElementDepth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlLoadSettings_get_ElementContentWhiteSpace(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ElementContentWhiteSpace());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlLoadSettings_put_ElementContentWhiteSpace(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* 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.ElementContentWhiteSpace(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlLoadSettings(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::Data::Xml::Dom::XmlLoadSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_XmlLoadSettings[] = {
        { "validate_on_parse", reinterpret_cast<getter>(XmlLoadSettings_get_ValidateOnParse), reinterpret_cast<setter>(XmlLoadSettings_put_ValidateOnParse), nullptr, nullptr },
        { "resolve_externals", reinterpret_cast<getter>(XmlLoadSettings_get_ResolveExternals), reinterpret_cast<setter>(XmlLoadSettings_put_ResolveExternals), nullptr, nullptr },
        { "prohibit_dtd", reinterpret_cast<getter>(XmlLoadSettings_get_ProhibitDtd), reinterpret_cast<setter>(XmlLoadSettings_put_ProhibitDtd), nullptr, nullptr },
        { "max_element_depth", reinterpret_cast<getter>(XmlLoadSettings_get_MaxElementDepth), reinterpret_cast<setter>(XmlLoadSettings_put_MaxElementDepth), nullptr, nullptr },
        { "element_content_white_space", reinterpret_cast<getter>(XmlLoadSettings_get_ElementContentWhiteSpace), reinterpret_cast<setter>(XmlLoadSettings_put_ElementContentWhiteSpace), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlLoadSettings[] = 
    {
        { Py_tp_new, _new_XmlLoadSettings },
        { Py_tp_dealloc, _dealloc_XmlLoadSettings },
        { Py_tp_methods, _methods_XmlLoadSettings },
        { Py_tp_getset, _getset_XmlLoadSettings },
        { },
    };

    static PyType_Spec _type_spec_XmlLoadSettings =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlLoadSettings",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlLoadSettings
    };

    // ----- XmlNamedNodeMap class --------------------
    constexpr const char* const _type_name_XmlNamedNodeMap = "XmlNamedNodeMap";

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

    static void _dealloc_XmlNamedNodeMap(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlNamedNodeMap_First(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlNamedNodeMap_GetAt(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNamedNodeMap_GetMany(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);
                auto param1_count = py::convert_to<winrt::com_array<winrt::Windows::Data::Xml::Dom::IXmlNode>::size_type>(args, 1);
                winrt::com_array<winrt::Windows::Data::Xml::Dom::IXmlNode> param1 ( param1_count, py::empty_instance<winrt::Windows::Data::Xml::Dom::IXmlNode>::get() );

                auto return_value = self->obj.GetMany(param0, param1);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out1{ py::convert(param1) };
                if (!out1)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out1.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlNamedNodeMap_GetNamedItem(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNamedNodeMap_GetNamedItemNS(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNamedNodeMap_IndexOf(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* 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::IXmlNode>(args, 0);
                uint32_t param1 {  };

                auto return_value = self->obj.IndexOf(param0, param1);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out1{ py::convert(param1) };
                if (!out1)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out1.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlNamedNodeMap_Item(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNamedNodeMap_RemoveNamedItem(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNamedNodeMap_RemoveNamedItemNS(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNamedNodeMap_SetNamedItem(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlNamedNodeMap_SetNamedItemNS(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlNamedNodeMap_get_Length(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlNamedNodeMap_get_Size(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_XmlNamedNodeMap(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::Data::Xml::Dom::XmlNamedNodeMap>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_XmlNamedNodeMap(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_XmlNamedNodeMap(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_XmlNamedNodeMap(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, Py_ssize_t i) noexcept
    {
        try
        {
            return py::convert(self->obj.GetAt(static_cast<uint32_t>(i)));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlNamedNodeMap[] = {
        { "first", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_GetMany), METH_VARARGS, nullptr },
        { "get_named_item", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_GetNamedItem), METH_VARARGS, nullptr },
        { "get_named_item_n_s", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_GetNamedItemNS), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_IndexOf), METH_VARARGS, nullptr },
        { "item", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_Item), METH_VARARGS, nullptr },
        { "remove_named_item", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_RemoveNamedItem), METH_VARARGS, nullptr },
        { "remove_named_item_n_s", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_RemoveNamedItemNS), METH_VARARGS, nullptr },
        { "set_named_item", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_SetNamedItem), METH_VARARGS, nullptr },
        { "set_named_item_n_s", reinterpret_cast<PyCFunction>(XmlNamedNodeMap_SetNamedItemNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlNamedNodeMap), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlNamedNodeMap[] = {
        { "length", reinterpret_cast<getter>(XmlNamedNodeMap_get_Length), nullptr, nullptr, nullptr },
        { "size", reinterpret_cast<getter>(XmlNamedNodeMap_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlNamedNodeMap[] = 
    {
        { Py_tp_new, _new_XmlNamedNodeMap },
        { Py_tp_dealloc, _dealloc_XmlNamedNodeMap },
        { Py_tp_methods, _methods_XmlNamedNodeMap },
        { Py_tp_getset, _getset_XmlNamedNodeMap },
        { Py_tp_iter, _iterator_XmlNamedNodeMap },
        { Py_sq_length, _seq_length_XmlNamedNodeMap },
        { Py_sq_item, _seq_item_XmlNamedNodeMap },
        { },
    };

    static PyType_Spec _type_spec_XmlNamedNodeMap =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlNamedNodeMap",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlNamedNodeMap
    };

    // ----- XmlNodeList class --------------------
    constexpr const char* const _type_name_XmlNodeList = "XmlNodeList";

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

    static void _dealloc_XmlNodeList(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlNodeList_First(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlNodeList_GetAt(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNodeList_GetMany(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);
                auto param1_count = py::convert_to<winrt::com_array<winrt::Windows::Data::Xml::Dom::IXmlNode>::size_type>(args, 1);
                winrt::com_array<winrt::Windows::Data::Xml::Dom::IXmlNode> param1 ( param1_count, py::empty_instance<winrt::Windows::Data::Xml::Dom::IXmlNode>::get() );

                auto return_value = self->obj.GetMany(param0, param1);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out1{ py::convert(param1) };
                if (!out1)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out1.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlNodeList_IndexOf(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* 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::IXmlNode>(args, 0);
                uint32_t param1 {  };

                auto return_value = self->obj.IndexOf(param0, param1);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out1{ py::convert(param1) };
                if (!out1)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out1.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlNodeList_Item(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlNodeList_get_Length(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlNodeList_get_Size(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_XmlNodeList(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::Data::Xml::Dom::XmlNodeList>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_XmlNodeList(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_XmlNodeList(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_XmlNodeList(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, Py_ssize_t i) noexcept
    {
        try
        {
            return py::convert(self->obj.GetAt(static_cast<uint32_t>(i)));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlNodeList[] = {
        { "first", reinterpret_cast<PyCFunction>(XmlNodeList_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(XmlNodeList_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(XmlNodeList_GetMany), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(XmlNodeList_IndexOf), METH_VARARGS, nullptr },
        { "item", reinterpret_cast<PyCFunction>(XmlNodeList_Item), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlNodeList), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlNodeList[] = {
        { "length", reinterpret_cast<getter>(XmlNodeList_get_Length), nullptr, nullptr, nullptr },
        { "size", reinterpret_cast<getter>(XmlNodeList_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlNodeList[] = 
    {
        { Py_tp_new, _new_XmlNodeList },
        { Py_tp_dealloc, _dealloc_XmlNodeList },
        { Py_tp_methods, _methods_XmlNodeList },
        { Py_tp_getset, _getset_XmlNodeList },
        { Py_tp_iter, _iterator_XmlNodeList },
        { Py_sq_length, _seq_length_XmlNodeList },
        { Py_sq_item, _seq_item_XmlNodeList },
        { },
    };

    static PyType_Spec _type_spec_XmlNodeList =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlNodeList",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlNodeList
    };

    // ----- XmlProcessingInstruction class --------------------
    constexpr const char* const _type_name_XmlProcessingInstruction = "XmlProcessingInstruction";

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

    static void _dealloc_XmlProcessingInstruction(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlProcessingInstruction_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlProcessingInstruction_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlProcessingInstruction_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlProcessingInstruction_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlProcessingInstruction_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlProcessingInstruction_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlProcessingInstruction_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlProcessingInstruction_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlProcessingInstruction_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlProcessingInstruction_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlProcessingInstruction_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlProcessingInstruction_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlProcessingInstruction_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlProcessingInstruction_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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::IInspectable>(arg);

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

    static PyObject* XmlProcessingInstruction_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlProcessingInstruction_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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::IInspectable>(arg);

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

    static PyObject* XmlProcessingInstruction_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlProcessingInstruction_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlProcessingInstruction_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlProcessingInstruction_get_Data(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlProcessingInstruction_put_Data(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* 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.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlProcessingInstruction_get_Target(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Target());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_XmlProcessingInstruction(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::Data::Xml::Dom::XmlProcessingInstruction>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlProcessingInstruction[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_CloneNode), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlProcessingInstruction_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlProcessingInstruction), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlProcessingInstruction[] = {
        { "prefix", reinterpret_cast<getter>(XmlProcessingInstruction_get_Prefix), reinterpret_cast<setter>(XmlProcessingInstruction_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlProcessingInstruction_get_NodeValue), reinterpret_cast<setter>(XmlProcessingInstruction_put_NodeValue), nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlProcessingInstruction_get_Attributes), nullptr, nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlProcessingInstruction_get_FirstChild), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlProcessingInstruction_get_ChildNodes), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlProcessingInstruction_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlProcessingInstruction_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlProcessingInstruction_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlProcessingInstruction_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlProcessingInstruction_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlProcessingInstruction_get_NodeType), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlProcessingInstruction_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlProcessingInstruction_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlProcessingInstruction_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlProcessingInstruction_get_InnerText), reinterpret_cast<setter>(XmlProcessingInstruction_put_InnerText), nullptr, nullptr },
        { "data", reinterpret_cast<getter>(XmlProcessingInstruction_get_Data), reinterpret_cast<setter>(XmlProcessingInstruction_put_Data), nullptr, nullptr },
        { "target", reinterpret_cast<getter>(XmlProcessingInstruction_get_Target), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlProcessingInstruction[] = 
    {
        { Py_tp_new, _new_XmlProcessingInstruction },
        { Py_tp_dealloc, _dealloc_XmlProcessingInstruction },
        { Py_tp_methods, _methods_XmlProcessingInstruction },
        { Py_tp_getset, _getset_XmlProcessingInstruction },
        { },
    };

    static PyType_Spec _type_spec_XmlProcessingInstruction =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlProcessingInstruction",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlProcessingInstruction
    };

    // ----- XmlText class --------------------
    constexpr const char* const _type_name_XmlText = "XmlText";

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

    static void _dealloc_XmlText(py::wrapper::Windows::Data::Xml::Dom::XmlText* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* XmlText_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlText_AppendData(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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.AppendData(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XmlText_CloneNode(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_DeleteData(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_GetXml(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlText_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlText_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_InsertData(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_Normalize(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* XmlText_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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::IXmlNode>(args, 0);

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

    static PyObject* XmlText_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_ReplaceData(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlText_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* XmlText_SplitText(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_SubstringData(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* XmlText_get_Data(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlText_put_Data(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XmlText_get_Length(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlText_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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::IInspectable>(arg);

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

    static PyObject* XmlText_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlText_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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::IInspectable>(arg);

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

    static PyObject* XmlText_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* XmlText_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XmlText_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::XmlText* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_XmlText(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::Data::Xml::Dom::XmlText>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XmlText[] = {
        { "append_child", reinterpret_cast<PyCFunction>(XmlText_AppendChild), METH_VARARGS, nullptr },
        { "append_data", reinterpret_cast<PyCFunction>(XmlText_AppendData), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(XmlText_CloneNode), METH_VARARGS, nullptr },
        { "delete_data", reinterpret_cast<PyCFunction>(XmlText_DeleteData), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(XmlText_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(XmlText_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(XmlText_InsertBefore), METH_VARARGS, nullptr },
        { "insert_data", reinterpret_cast<PyCFunction>(XmlText_InsertData), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(XmlText_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(XmlText_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(XmlText_ReplaceChild), METH_VARARGS, nullptr },
        { "replace_data", reinterpret_cast<PyCFunction>(XmlText_ReplaceData), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(XmlText_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(XmlText_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(XmlText_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(XmlText_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "split_text", reinterpret_cast<PyCFunction>(XmlText_SplitText), METH_VARARGS, nullptr },
        { "substring_data", reinterpret_cast<PyCFunction>(XmlText_SubstringData), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XmlText), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XmlText[] = {
        { "data", reinterpret_cast<getter>(XmlText_get_Data), reinterpret_cast<setter>(XmlText_put_Data), nullptr, nullptr },
        { "length", reinterpret_cast<getter>(XmlText_get_Length), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(XmlText_get_Prefix), reinterpret_cast<setter>(XmlText_put_Prefix), nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(XmlText_get_NodeValue), reinterpret_cast<setter>(XmlText_put_NodeValue), nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(XmlText_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(XmlText_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(XmlText_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(XmlText_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(XmlText_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(XmlText_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(XmlText_get_NodeType), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(XmlText_get_Attributes), nullptr, nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(XmlText_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(XmlText_get_ChildNodes), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(XmlText_get_ParentNode), nullptr, nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(XmlText_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(XmlText_get_InnerText), reinterpret_cast<setter>(XmlText_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XmlText[] = 
    {
        { Py_tp_new, _new_XmlText },
        { Py_tp_dealloc, _dealloc_XmlText },
        { Py_tp_methods, _methods_XmlText },
        { Py_tp_getset, _getset_XmlText },
        { },
    };

    static PyType_Spec _type_spec_XmlText =
    {
        "_winsdk_Windows_Data_Xml_Dom.XmlText",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlText),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlText
    };

    // ----- IXmlCharacterData interface --------------------
    constexpr const char* const _type_name_IXmlCharacterData = "IXmlCharacterData";

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

    static void _dealloc_IXmlCharacterData(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IXmlCharacterData_AppendChild(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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::IXmlNode>(args, 0);

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

    static PyObject* IXmlCharacterData_AppendData(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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.AppendData(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_CloneNode(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_DeleteData(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_GetXml(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlCharacterData_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlCharacterData_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_InsertData(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_Normalize(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlCharacterData_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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::IXmlNode>(args, 0);

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

    static PyObject* IXmlCharacterData_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_ReplaceData(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* IXmlCharacterData_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* IXmlCharacterData_SubstringData(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlCharacterData_get_Data(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlCharacterData_put_Data(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IXmlCharacterData_get_Length(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlCharacterData_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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::IInspectable>(arg);

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

    static PyObject* IXmlCharacterData_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlCharacterData_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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::IInspectable>(arg);

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

    static PyObject* IXmlCharacterData_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlCharacterData_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlCharacterData_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_IXmlCharacterData(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::Data::Xml::Dom::IXmlCharacterData>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IXmlCharacterData[] = {
        { "append_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_AppendData), METH_VARARGS, nullptr },
        { "delete_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_DeleteData), METH_VARARGS, nullptr },
        { "insert_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_InsertData), METH_VARARGS, nullptr },
        { "replace_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_ReplaceData), METH_VARARGS, nullptr },
        { "substring_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_SubstringData), METH_VARARGS, nullptr },
        { "append_child", reinterpret_cast<PyCFunction>(IXmlCharacterData_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(IXmlCharacterData_CloneNode), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(IXmlCharacterData_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(IXmlCharacterData_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(IXmlCharacterData_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(IXmlCharacterData_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(IXmlCharacterData_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(IXmlCharacterData_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(IXmlCharacterData_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(IXmlCharacterData_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(IXmlCharacterData_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(IXmlCharacterData_GetXml), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IXmlCharacterData), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IXmlCharacterData[] = {
        { "data", reinterpret_cast<getter>(IXmlCharacterData_get_Data), reinterpret_cast<setter>(IXmlCharacterData_put_Data), nullptr, nullptr },
        { "length", reinterpret_cast<getter>(IXmlCharacterData_get_Length), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(IXmlCharacterData_get_Attributes), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(IXmlCharacterData_get_ChildNodes), nullptr, nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(IXmlCharacterData_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(IXmlCharacterData_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(IXmlCharacterData_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(IXmlCharacterData_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(IXmlCharacterData_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(IXmlCharacterData_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(IXmlCharacterData_get_NodeType), nullptr, nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(IXmlCharacterData_get_NodeValue), reinterpret_cast<setter>(IXmlCharacterData_put_NodeValue), nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(IXmlCharacterData_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(IXmlCharacterData_get_ParentNode), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(IXmlCharacterData_get_Prefix), reinterpret_cast<setter>(IXmlCharacterData_put_Prefix), nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(IXmlCharacterData_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(IXmlCharacterData_get_InnerText), reinterpret_cast<setter>(IXmlCharacterData_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IXmlCharacterData[] = 
    {
        { Py_tp_new, _new_IXmlCharacterData },
        { Py_tp_dealloc, _dealloc_IXmlCharacterData },
        { Py_tp_methods, _methods_IXmlCharacterData },
        { Py_tp_getset, _getset_IXmlCharacterData },
        { },
    };

    static PyType_Spec _type_spec_IXmlCharacterData =
    {
        "_winsdk_Windows_Data_Xml_Dom.IXmlCharacterData",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlCharacterData
    };

    // ----- IXmlNode interface --------------------
    constexpr const char* const _type_name_IXmlNode = "IXmlNode";

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

    static void _dealloc_IXmlNode(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IXmlNode_AppendChild(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* 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::IXmlNode>(args, 0);

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

    static PyObject* IXmlNode_CloneNode(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlNode_GetXml(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlNode_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlNode_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlNode_Normalize(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlNode_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* 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::IXmlNode>(args, 0);

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

    static PyObject* IXmlNode_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlNode_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlNode_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* IXmlNode_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlNode_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* IXmlNode_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlNode_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* 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::IInspectable>(arg);

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

    static PyObject* IXmlNode_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlNode_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* 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::IInspectable>(arg);

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

    static PyObject* IXmlNode_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlNode_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlNode_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_IXmlNode(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::Data::Xml::Dom::IXmlNode>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IXmlNode[] = {
        { "append_child", reinterpret_cast<PyCFunction>(IXmlNode_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(IXmlNode_CloneNode), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(IXmlNode_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(IXmlNode_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(IXmlNode_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(IXmlNode_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(IXmlNode_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(IXmlNode_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(IXmlNode_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(IXmlNode_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(IXmlNode_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(IXmlNode_GetXml), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IXmlNode), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IXmlNode[] = {
        { "attributes", reinterpret_cast<getter>(IXmlNode_get_Attributes), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(IXmlNode_get_ChildNodes), nullptr, nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(IXmlNode_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(IXmlNode_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(IXmlNode_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(IXmlNode_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(IXmlNode_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(IXmlNode_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(IXmlNode_get_NodeType), nullptr, nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(IXmlNode_get_NodeValue), reinterpret_cast<setter>(IXmlNode_put_NodeValue), nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(IXmlNode_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(IXmlNode_get_ParentNode), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(IXmlNode_get_Prefix), reinterpret_cast<setter>(IXmlNode_put_Prefix), nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(IXmlNode_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(IXmlNode_get_InnerText), reinterpret_cast<setter>(IXmlNode_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IXmlNode[] = 
    {
        { Py_tp_new, _new_IXmlNode },
        { Py_tp_dealloc, _dealloc_IXmlNode },
        { Py_tp_methods, _methods_IXmlNode },
        { Py_tp_getset, _getset_IXmlNode },
        { },
    };

    static PyType_Spec _type_spec_IXmlNode =
    {
        "_winsdk_Windows_Data_Xml_Dom.IXmlNode",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlNode),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlNode
    };

    // ----- IXmlNodeSelector interface --------------------
    constexpr const char* const _type_name_IXmlNodeSelector = "IXmlNodeSelector";

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

    static void _dealloc_IXmlNodeSelector(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IXmlNodeSelector_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlNodeSelector_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* IXmlNodeSelector_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlNodeSelector_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* _from_IXmlNodeSelector(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::Data::Xml::Dom::IXmlNodeSelector>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IXmlNodeSelector[] = {
        { "select_nodes", reinterpret_cast<PyCFunction>(IXmlNodeSelector_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(IXmlNodeSelector_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(IXmlNodeSelector_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(IXmlNodeSelector_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IXmlNodeSelector), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IXmlNodeSelector[] = {
        { }
    };

    static PyType_Slot _type_slots_IXmlNodeSelector[] = 
    {
        { Py_tp_new, _new_IXmlNodeSelector },
        { Py_tp_dealloc, _dealloc_IXmlNodeSelector },
        { Py_tp_methods, _methods_IXmlNodeSelector },
        { Py_tp_getset, _getset_IXmlNodeSelector },
        { },
    };

    static PyType_Spec _type_spec_IXmlNodeSelector =
    {
        "_winsdk_Windows_Data_Xml_Dom.IXmlNodeSelector",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlNodeSelector
    };

    // ----- IXmlNodeSerializer interface --------------------
    constexpr const char* const _type_name_IXmlNodeSerializer = "IXmlNodeSerializer";

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

    static void _dealloc_IXmlNodeSerializer(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IXmlNodeSerializer_GetXml(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlNodeSerializer_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlNodeSerializer_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_IXmlNodeSerializer(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::Data::Xml::Dom::IXmlNodeSerializer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IXmlNodeSerializer[] = {
        { "get_xml", reinterpret_cast<PyCFunction>(IXmlNodeSerializer_GetXml), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IXmlNodeSerializer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IXmlNodeSerializer[] = {
        { "inner_text", reinterpret_cast<getter>(IXmlNodeSerializer_get_InnerText), reinterpret_cast<setter>(IXmlNodeSerializer_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IXmlNodeSerializer[] = 
    {
        { Py_tp_new, _new_IXmlNodeSerializer },
        { Py_tp_dealloc, _dealloc_IXmlNodeSerializer },
        { Py_tp_methods, _methods_IXmlNodeSerializer },
        { Py_tp_getset, _getset_IXmlNodeSerializer },
        { },
    };

    static PyType_Spec _type_spec_IXmlNodeSerializer =
    {
        "_winsdk_Windows_Data_Xml_Dom.IXmlNodeSerializer",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlNodeSerializer
    };

    // ----- IXmlText interface --------------------
    constexpr const char* const _type_name_IXmlText = "IXmlText";

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

    static void _dealloc_IXmlText(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IXmlText_AppendChild(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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::IXmlNode>(args, 0);

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

    static PyObject* IXmlText_AppendData(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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.AppendData(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IXmlText_CloneNode(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_DeleteData(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_GetXml(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlText_HasChildNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlText_InsertBefore(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_InsertData(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_Normalize(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IXmlText_RemoveChild(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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::IXmlNode>(args, 0);

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

    static PyObject* IXmlText_ReplaceChild(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_ReplaceData(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_SelectNodesNS(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* IXmlText_SelectSingleNode(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_SelectSingleNodeNS(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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::Windows::Foundation::IInspectable>(args, 1);

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

    static PyObject* IXmlText_SplitText(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_SubstringData(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IXmlText_get_Data(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Data());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlText_put_Data(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IXmlText_get_Length(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_Attributes(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_ChildNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ChildNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_FirstChild(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FirstChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_LastChild(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LastChild());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_LocalName(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.LocalName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_NamespaceUri(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NamespaceUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_NextSibling(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NextSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_NodeName(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_NodeType(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_NodeValue(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.NodeValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlText_put_NodeValue(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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::IInspectable>(arg);

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

    static PyObject* IXmlText_get_OwnerDocument(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OwnerDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_ParentNode(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ParentNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_Prefix(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Prefix());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlText_put_Prefix(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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::IInspectable>(arg);

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

    static PyObject* IXmlText_get_PreviousSibling(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PreviousSibling());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IXmlText_get_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.InnerText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IXmlText_put_InnerText(py::wrapper::Windows::Data::Xml::Dom::IXmlText* 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.InnerText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_IXmlText(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::Data::Xml::Dom::IXmlText>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IXmlText[] = {
        { "split_text", reinterpret_cast<PyCFunction>(IXmlText_SplitText), METH_VARARGS, nullptr },
        { "append_data", reinterpret_cast<PyCFunction>(IXmlText_AppendData), METH_VARARGS, nullptr },
        { "delete_data", reinterpret_cast<PyCFunction>(IXmlText_DeleteData), METH_VARARGS, nullptr },
        { "insert_data", reinterpret_cast<PyCFunction>(IXmlText_InsertData), METH_VARARGS, nullptr },
        { "replace_data", reinterpret_cast<PyCFunction>(IXmlText_ReplaceData), METH_VARARGS, nullptr },
        { "substring_data", reinterpret_cast<PyCFunction>(IXmlText_SubstringData), METH_VARARGS, nullptr },
        { "append_child", reinterpret_cast<PyCFunction>(IXmlText_AppendChild), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(IXmlText_CloneNode), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(IXmlText_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(IXmlText_InsertBefore), METH_VARARGS, nullptr },
        { "normalize", reinterpret_cast<PyCFunction>(IXmlText_Normalize), METH_VARARGS, nullptr },
        { "remove_child", reinterpret_cast<PyCFunction>(IXmlText_RemoveChild), METH_VARARGS, nullptr },
        { "replace_child", reinterpret_cast<PyCFunction>(IXmlText_ReplaceChild), METH_VARARGS, nullptr },
        { "select_nodes", reinterpret_cast<PyCFunction>(IXmlText_SelectNodes), METH_VARARGS, nullptr },
        { "select_nodes_n_s", reinterpret_cast<PyCFunction>(IXmlText_SelectNodesNS), METH_VARARGS, nullptr },
        { "select_single_node", reinterpret_cast<PyCFunction>(IXmlText_SelectSingleNode), METH_VARARGS, nullptr },
        { "select_single_node_n_s", reinterpret_cast<PyCFunction>(IXmlText_SelectSingleNodeNS), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(IXmlText_GetXml), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IXmlText), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IXmlText[] = {
        { "data", reinterpret_cast<getter>(IXmlText_get_Data), reinterpret_cast<setter>(IXmlText_put_Data), nullptr, nullptr },
        { "length", reinterpret_cast<getter>(IXmlText_get_Length), nullptr, nullptr, nullptr },
        { "attributes", reinterpret_cast<getter>(IXmlText_get_Attributes), nullptr, nullptr, nullptr },
        { "child_nodes", reinterpret_cast<getter>(IXmlText_get_ChildNodes), nullptr, nullptr, nullptr },
        { "first_child", reinterpret_cast<getter>(IXmlText_get_FirstChild), nullptr, nullptr, nullptr },
        { "last_child", reinterpret_cast<getter>(IXmlText_get_LastChild), nullptr, nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(IXmlText_get_LocalName), nullptr, nullptr, nullptr },
        { "namespace_uri", reinterpret_cast<getter>(IXmlText_get_NamespaceUri), nullptr, nullptr, nullptr },
        { "next_sibling", reinterpret_cast<getter>(IXmlText_get_NextSibling), nullptr, nullptr, nullptr },
        { "node_name", reinterpret_cast<getter>(IXmlText_get_NodeName), nullptr, nullptr, nullptr },
        { "node_type", reinterpret_cast<getter>(IXmlText_get_NodeType), nullptr, nullptr, nullptr },
        { "node_value", reinterpret_cast<getter>(IXmlText_get_NodeValue), reinterpret_cast<setter>(IXmlText_put_NodeValue), nullptr, nullptr },
        { "owner_document", reinterpret_cast<getter>(IXmlText_get_OwnerDocument), nullptr, nullptr, nullptr },
        { "parent_node", reinterpret_cast<getter>(IXmlText_get_ParentNode), nullptr, nullptr, nullptr },
        { "prefix", reinterpret_cast<getter>(IXmlText_get_Prefix), reinterpret_cast<setter>(IXmlText_put_Prefix), nullptr, nullptr },
        { "previous_sibling", reinterpret_cast<getter>(IXmlText_get_PreviousSibling), nullptr, nullptr, nullptr },
        { "inner_text", reinterpret_cast<getter>(IXmlText_get_InnerText), reinterpret_cast<setter>(IXmlText_put_InnerText), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IXmlText[] = 
    {
        { Py_tp_new, _new_IXmlText },
        { Py_tp_dealloc, _dealloc_IXmlText },
        { Py_tp_methods, _methods_IXmlText },
        { Py_tp_getset, _getset_IXmlText },
        { },
    };

    static PyType_Spec _type_spec_IXmlText =
    {
        "_winsdk_Windows_Data_Xml_Dom.IXmlText",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlText),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlText
    };

    // ----- Windows.Data.Xml.Dom 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::Data::Xml::Dom::DtdEntity>::python_type = py::register_python_type(module, _type_name_DtdEntity, &_type_spec_DtdEntity, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::DtdNotation>::python_type = py::register_python_type(module, _type_name_DtdNotation, &_type_spec_DtdNotation, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlAttribute>::python_type = py::register_python_type(module, _type_name_XmlAttribute, &_type_spec_XmlAttribute, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlCDataSection>::python_type = py::register_python_type(module, _type_name_XmlCDataSection, &_type_spec_XmlCDataSection, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlComment>::python_type = py::register_python_type(module, _type_name_XmlComment, &_type_spec_XmlComment, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocument>::python_type = py::register_python_type(module, _type_name_XmlDocument, &_type_spec_XmlDocument, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocumentFragment>::python_type = py::register_python_type(module, _type_name_XmlDocumentFragment, &_type_spec_XmlDocumentFragment, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocumentType>::python_type = py::register_python_type(module, _type_name_XmlDocumentType, &_type_spec_XmlDocumentType, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDomImplementation>::python_type = py::register_python_type(module, _type_name_XmlDomImplementation, &_type_spec_XmlDomImplementation, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlElement>::python_type = py::register_python_type(module, _type_name_XmlElement, &_type_spec_XmlElement, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlEntityReference>::python_type = py::register_python_type(module, _type_name_XmlEntityReference, &_type_spec_XmlEntityReference, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlLoadSettings>::python_type = py::register_python_type(module, _type_name_XmlLoadSettings, &_type_spec_XmlLoadSettings, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlNamedNodeMap>::python_type = py::register_python_type(module, _type_name_XmlNamedNodeMap, &_type_spec_XmlNamedNodeMap, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlNodeList>::python_type = py::register_python_type(module, _type_name_XmlNodeList, &_type_spec_XmlNodeList, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlProcessingInstruction>::python_type = py::register_python_type(module, _type_name_XmlProcessingInstruction, &_type_spec_XmlProcessingInstruction, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlText>::python_type = py::register_python_type(module, _type_name_XmlText, &_type_spec_XmlText, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlCharacterData>::python_type = py::register_python_type(module, _type_name_IXmlCharacterData, &_type_spec_IXmlCharacterData, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNode>::python_type = py::register_python_type(module, _type_name_IXmlNode, &_type_spec_IXmlNode, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNodeSelector>::python_type = py::register_python_type(module, _type_name_IXmlNodeSelector, &_type_spec_IXmlNodeSelector, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNodeSerializer>::python_type = py::register_python_type(module, _type_name_IXmlNodeSerializer, &_type_spec_IXmlNodeSerializer, bases.get());
            py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlText>::python_type = py::register_python_type(module, _type_name_IXmlText, &_type_spec_IXmlText, 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.Data.Xml.Dom");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Data_Xml_Dom",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::Data::Xml::Dom

PyMODINIT_FUNC
PyInit__winsdk_Windows_Data_Xml_Dom (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Data::Xml::Dom::module_def);
}
