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

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


namespace py::cpp::Windows::Data::Xml::Dom
{
    struct module_state
    {
        PyObject* type_NodeType;
        PyTypeObject* type_DtdEntity;
        PyTypeObject* type_DtdNotation;
        PyTypeObject* type_XmlAttribute;
        PyTypeObject* type_XmlCDataSection;
        PyTypeObject* type_XmlComment;
        PyTypeObject* type_XmlDocument;
        PyTypeObject* type_XmlDocumentFragment;
        PyTypeObject* type_XmlDocumentType;
        PyTypeObject* type_XmlDomImplementation;
        PyTypeObject* type_XmlElement;
        PyTypeObject* type_XmlEntityReference;
        PyTypeObject* type_XmlLoadSettings;
        PyTypeObject* type_XmlNamedNodeMap;
        PyTypeObject* type_XmlNodeList;
        PyTypeObject* type_XmlProcessingInstruction;
        PyTypeObject* type_XmlText;
        PyTypeObject* type_IXmlCharacterData;
        PyTypeObject* type_IXmlNode;
        PyTypeObject* type_IXmlNodeSelector;
        PyTypeObject* type_IXmlNodeSerializer;
        PyTypeObject* type_IXmlText;
    };

    static PyObject* register_NodeType(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_NodeType)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_NodeType = type;
        Py_INCREF(state->type_NodeType);


        Py_RETURN_NONE;
    }

    // ----- DtdEntity class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"NotationName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"PublicId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"SystemId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdEntity", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_DtdEntity(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::DtdEntity>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_DtdEntity, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_DtdEntity) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DtdEntity) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DtdEntity) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DtdEntity) },
        { },
    };

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

    // ----- DtdNotation class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"PublicId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"SystemId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.DtdNotation", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_DtdNotation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::DtdNotation>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_DtdNotation, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_DtdNotation) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DtdNotation) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DtdNotation) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DtdNotation) },
        { },
    };

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

    // ----- XmlAttribute class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Value"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Value"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Specified"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Name"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlAttribute", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlAttribute(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlAttribute>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlAttribute, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlAttribute) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlAttribute) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlAttribute) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlAttribute) },
        { },
    };

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

    // ----- XmlCDataSection class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"AppendData", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"DeleteData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"InsertData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"ReplaceData", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"SplitText", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"SubstringData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlCDataSection", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlCDataSection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlCDataSection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlCDataSection, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlCDataSection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlCDataSection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlCDataSection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlCDataSection) },
        { },
    };

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

    // ----- XmlComment class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"AppendData", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"DeleteData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"InsertData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"ReplaceData", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlComment", L"SubstringData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlComment", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlComment(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlComment>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlComment, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlComment) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlComment) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlComment) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlComment) },
        { },
    };

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

    // ----- XmlDocument class --------------------
    static 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;
        }

        auto 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateAttribute", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateAttributeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateCDataSection", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateComment", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateDocumentFragment", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateElement", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateElementNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateEntityReference", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateProcessingInstruction", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"CreateTextNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"GetElementById", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"GetElementsByTagName", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"ImportNode", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadFromFileAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadFromFileAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadFromUriAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadFromUriAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadXml", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadXml", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadXmlFromBuffer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LoadXmlFromBuffer", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"SaveToFileAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"Doctype"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"DocumentElement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"DocumentUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"Implementation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocument", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlDocument(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlDocument>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlDocument, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlDocument) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlDocument) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlDocument) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlDocument) },
        { },
    };

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

    // ----- XmlDocumentFragment class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentFragment", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlDocumentFragment(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlDocumentFragment>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlDocumentFragment, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlDocumentFragment) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlDocumentFragment) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlDocumentFragment) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlDocumentFragment) },
        { },
    };

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

    // ----- XmlDocumentType class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"Entities"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"Name"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"Notations"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlDocumentType", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlDocumentType(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlDocumentType>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlDocumentType, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlDocumentType) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlDocumentType) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlDocumentType) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlDocumentType) },
        { },
    };

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

    // ----- XmlDomImplementation class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* XmlDomImplementation_HasFeature(py::wrapper::Windows::Data::Xml::Dom::XmlDomImplementation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlDomImplementation", L"HasFeature", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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* _assign_array_XmlDomImplementation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlDomImplementation>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlDomImplementation, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlDomImplementation) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlDomImplementation) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlDomImplementation) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlDomImplementation) },
        { },
    };

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

    // ----- XmlElement class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"GetAttribute", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"GetAttributeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"GetAttributeNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"GetAttributeNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"GetElementsByTagName", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"RemoveAttribute", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"RemoveAttributeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"RemoveAttributeNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SetAttribute", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SetAttributeNS", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SetAttributeNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlElement", L"SetAttributeNodeNS", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"TagName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlElement", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlElement>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlElement, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlElement) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlElement) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlElement) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlElement) },
        { },
    };

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

    // ----- XmlEntityReference class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlEntityReference", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlEntityReference(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlEntityReference>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlEntityReference, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlEntityReference) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlEntityReference) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlEntityReference) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlEntityReference) },
        { },
    };

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

    // ----- XmlLoadSettings class --------------------
    static 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;
        }

        auto 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* XmlLoadSettings_get_ValidateOnParse(py::wrapper::Windows::Data::Xml::Dom::XmlLoadSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ValidateOnParse"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ValidateOnParse"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ResolveExternals"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ResolveExternals"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ProhibitDtd"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ProhibitDtd"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"MaxElementDepth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"MaxElementDepth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ElementContentWhiteSpace"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlLoadSettings", L"ElementContentWhiteSpace"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlLoadSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlLoadSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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[] = {
        { "_assign_array_", _assign_array_XmlLoadSettings, METH_O | METH_STATIC, nullptr },
        { "_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, reinterpret_cast<void*>(_new_XmlLoadSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlLoadSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlLoadSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlLoadSettings) },
        { },
    };

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

    // ----- XmlNamedNodeMap class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"First", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"GetAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"GetMany", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.GetMany(param0, param1));
            }
            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"GetNamedItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"GetNamedItemNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"Item", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"RemoveNamedItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"RemoveNamedItemNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"SetNamedItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"SetNamedItemNS", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlNamedNodeMap", L"Size"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_XmlNamedNodeMap(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlNamedNodeMap>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 PyObject* _seq_subscript_XmlNamedNodeMap(py::wrapper::Windows::Data::Xml::Dom::XmlNamedNodeMap* self, PyObject* slice) noexcept
    {
        try
        {
            if (PyIndex_Check(slice))
            {
                pyobj_handle index{PyNumber_Index(slice)};

                if (!index)
                {
                    return nullptr;
                }

                auto i = PyNumber_AsSsize_t(index.get(), PyExc_IndexError);

                if (i == -1 && PyErr_Occurred())
                {
                    return nullptr;
                }

                return _seq_item_XmlNamedNodeMap(self, i);
            }

            if (!PySlice_Check(slice))
            {
                PyErr_Format(
                    PyExc_TypeError,
                    "indicies must be integers, not '%s'",
                    Py_TYPE(slice)->tp_name);
            }

            Py_ssize_t start, stop, step, length;

            if (PySlice_GetIndicesEx(
                    slice, self->obj.Size(), &start, &stop, &step, &length)
                < 0)
            {
                return nullptr;
            }

            if (step != 1)
            {
                PyErr_SetString(
                    PyExc_NotImplementedError,
                    "slices with step other than 1 are not implemented");
                return nullptr;
            }

            winrt::com_array<winrt::Windows::Data::Xml::Dom::IXmlNode> items(length, empty_instance<winrt::Windows::Data::Xml::Dom::IXmlNode>::get());

            auto count = self->obj.GetMany(start, items);

            if (count != length)
            {
                PyErr_Format(
                    PyExc_RuntimeError,
                    "returned count %d did not match requested length %zd",
                    count,
                    length);
                return nullptr;
            }

            return convert(items);}
        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 },
        { "_assign_array_", _assign_array_XmlNamedNodeMap, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlNamedNodeMap) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlNamedNodeMap) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlNamedNodeMap) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlNamedNodeMap) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_XmlNamedNodeMap) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_XmlNamedNodeMap) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_XmlNamedNodeMap) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_XmlNamedNodeMap) },
        { },
    };

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

    // ----- XmlNodeList class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNodeList", L"First", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNodeList", L"GetAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNodeList", L"GetMany", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.GetMany(param0, param1));
            }
            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNodeList", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlNodeList", L"Item", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlNodeList", L"Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlNodeList", L"Size"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_XmlNodeList(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlNodeList>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 PyObject* _seq_subscript_XmlNodeList(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList* self, PyObject* slice) noexcept
    {
        try
        {
            if (PyIndex_Check(slice))
            {
                pyobj_handle index{PyNumber_Index(slice)};

                if (!index)
                {
                    return nullptr;
                }

                auto i = PyNumber_AsSsize_t(index.get(), PyExc_IndexError);

                if (i == -1 && PyErr_Occurred())
                {
                    return nullptr;
                }

                return _seq_item_XmlNodeList(self, i);
            }

            if (!PySlice_Check(slice))
            {
                PyErr_Format(
                    PyExc_TypeError,
                    "indicies must be integers, not '%s'",
                    Py_TYPE(slice)->tp_name);
            }

            Py_ssize_t start, stop, step, length;

            if (PySlice_GetIndicesEx(
                    slice, self->obj.Size(), &start, &stop, &step, &length)
                < 0)
            {
                return nullptr;
            }

            if (step != 1)
            {
                PyErr_SetString(
                    PyExc_NotImplementedError,
                    "slices with step other than 1 are not implemented");
                return nullptr;
            }

            winrt::com_array<winrt::Windows::Data::Xml::Dom::IXmlNode> items(length, empty_instance<winrt::Windows::Data::Xml::Dom::IXmlNode>::get());

            auto count = self->obj.GetMany(start, items);

            if (count != length)
            {
                PyErr_Format(
                    PyExc_RuntimeError,
                    "returned count %d did not match requested length %zd",
                    count,
                    length);
                return nullptr;
            }

            return convert(items);}
        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 },
        { "_assign_array_", _assign_array_XmlNodeList, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlNodeList) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlNodeList) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlNodeList) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlNodeList) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_XmlNodeList) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_XmlNodeList) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_XmlNodeList) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_XmlNodeList) },
        { },
    };

    static PyType_Spec type_spec_XmlNodeList =
    {
        "_toasts_winrt_Windows_Data_Xml_Dom.XmlNodeList",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlNodeList),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlNodeList
    };

    // ----- XmlProcessingInstruction class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* XmlProcessingInstruction_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlProcessingInstruction", L"Target"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_XmlProcessingInstruction(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlProcessingInstruction>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlProcessingInstruction, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlProcessingInstruction) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlProcessingInstruction) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlProcessingInstruction) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlProcessingInstruction) },
        { },
    };

    static PyType_Spec type_spec_XmlProcessingInstruction =
    {
        "_toasts_winrt_Windows_Data_Xml_Dom.XmlProcessingInstruction",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlProcessingInstruction),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlProcessingInstruction
    };

    // ----- XmlText class --------------------
    static 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) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* XmlText_AppendChild(py::wrapper::Windows::Data::Xml::Dom::XmlText* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"AppendData", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"DeleteData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"InsertData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"ReplaceData", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"SplitText", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.XmlText", L"SubstringData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.XmlText", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_XmlText(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::XmlText>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_XmlText, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_XmlText) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XmlText) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XmlText) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XmlText) },
        { },
    };

    static PyType_Spec type_spec_XmlText =
    {
        "_toasts_winrt_Windows_Data_Xml_Dom.XmlText",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::XmlText),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XmlText
    };

    // ----- IXmlCharacterData interface --------------------
    static constexpr const char* const type_name_IXmlCharacterData = "IXmlCharacterData";

    static PyObject* _new_IXmlCharacterData(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */) noexcept
    {
        py::set_invalid_activation_error(type_name_IXmlCharacterData);
        return nullptr;
    }

    static void _dealloc_IXmlCharacterData(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IXmlCharacterData_AppendChild(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"AppendData", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"DeleteData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"InsertData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"ReplaceData", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"SubstringData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_IXmlCharacterData(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::IXmlCharacterData>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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_child", reinterpret_cast<PyCFunction>(IXmlCharacterData_AppendChild), METH_VARARGS, nullptr },
        { "append_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_AppendData), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(IXmlCharacterData_CloneNode), METH_VARARGS, nullptr },
        { "delete_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_DeleteData), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(IXmlCharacterData_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(IXmlCharacterData_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(IXmlCharacterData_InsertBefore), METH_VARARGS, nullptr },
        { "insert_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_InsertData), 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 },
        { "replace_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_ReplaceData), 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 },
        { "substring_data", reinterpret_cast<PyCFunction>(IXmlCharacterData_SubstringData), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IXmlCharacterData, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_IXmlCharacterData) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IXmlCharacterData) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IXmlCharacterData) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IXmlCharacterData) },
        { },
    };

    static PyType_Spec type_spec_IXmlCharacterData =
    {
        "_toasts_winrt_Windows_Data_Xml_Dom.IXmlCharacterData",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlCharacterData),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlCharacterData
    };

    // ----- IXmlNode interface --------------------
    static constexpr const char* const type_name_IXmlNode = "IXmlNode";

    static PyObject* _new_IXmlNode(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */) noexcept
    {
        py::set_invalid_activation_error(type_name_IXmlNode);
        return nullptr;
    }

    static void _dealloc_IXmlNode(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IXmlNode_AppendChild(py::wrapper::Windows::Data::Xml::Dom::IXmlNode* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_IXmlNode(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::IXmlNode>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "get_xml", reinterpret_cast<PyCFunction>(IXmlNode_GetXml), 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 },
        { "_assign_array_", _assign_array_IXmlNode, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_IXmlNode) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IXmlNode) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IXmlNode) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IXmlNode) },
        { },
    };

    static PyType_Spec type_spec_IXmlNode =
    {
        "_toasts_winrt_Windows_Data_Xml_Dom.IXmlNode",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlNode),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlNode
    };

    // ----- IXmlNodeSelector interface --------------------
    static constexpr const char* const type_name_IXmlNodeSelector = "IXmlNodeSelector";

    static PyObject* _new_IXmlNodeSelector(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */) noexcept
    {
        py::set_invalid_activation_error(type_name_IXmlNodeSelector);
        return nullptr;
    }

    static void _dealloc_IXmlNodeSelector(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IXmlNodeSelector_SelectNodes(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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* _assign_array_IXmlNodeSelector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::IXmlNodeSelector>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_IXmlNodeSelector, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_IXmlNodeSelector) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IXmlNodeSelector) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IXmlNodeSelector) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IXmlNodeSelector) },
        { },
    };

    static PyType_Spec type_spec_IXmlNodeSelector =
    {
        "_toasts_winrt_Windows_Data_Xml_Dom.IXmlNodeSelector",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSelector),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlNodeSelector
    };

    // ----- IXmlNodeSerializer interface --------------------
    static constexpr const char* const type_name_IXmlNodeSerializer = "IXmlNodeSerializer";

    static PyObject* _new_IXmlNodeSerializer(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */) noexcept
    {
        py::set_invalid_activation_error(type_name_IXmlNodeSerializer);
        return nullptr;
    }

    static void _dealloc_IXmlNodeSerializer(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IXmlNodeSerializer_GetXml(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_IXmlNodeSerializer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::IXmlNodeSerializer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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 },
        { "_assign_array_", _assign_array_IXmlNodeSerializer, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_IXmlNodeSerializer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IXmlNodeSerializer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IXmlNodeSerializer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IXmlNodeSerializer) },
        { },
    };

    static PyType_Spec type_spec_IXmlNodeSerializer =
    {
        "_toasts_winrt_Windows_Data_Xml_Dom.IXmlNodeSerializer",
        sizeof(py::wrapper::Windows::Data::Xml::Dom::IXmlNodeSerializer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IXmlNodeSerializer
    };

    // ----- IXmlText interface --------------------
    static constexpr const char* const type_name_IXmlText = "IXmlText";

    static PyObject* _new_IXmlText(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */) noexcept
    {
        py::set_invalid_activation_error(type_name_IXmlText);
        return nullptr;
    }

    static void _dealloc_IXmlText(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IXmlText_AppendChild(py::wrapper::Windows::Data::Xml::Dom::IXmlText* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"AppendChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"AppendData", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"CloneNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"DeleteData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"GetXml", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"HasChildNodes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"InsertBefore", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"InsertData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Normalize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"RemoveChild", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ReplaceChild", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"ReplaceData", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectNodesNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlNodeSelector", L"SelectSingleNodeNS", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlText", L"SplitText", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            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
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"SubstringData", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"Data"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

            self->obj.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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlCharacterData", L"Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Attributes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ChildNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"FirstChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"LastChild"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NextSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"NodeValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"OwnerDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"ParentNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"Prefix"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNode", L"PreviousSibling"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        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 (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Data.Xml.Dom.IXmlNodeSerializer", L"InnerText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_IXmlText(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Data::Xml::Dom::IXmlText>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    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[] = {
        { "append_child", reinterpret_cast<PyCFunction>(IXmlText_AppendChild), METH_VARARGS, nullptr },
        { "append_data", reinterpret_cast<PyCFunction>(IXmlText_AppendData), METH_VARARGS, nullptr },
        { "clone_node", reinterpret_cast<PyCFunction>(IXmlText_CloneNode), METH_VARARGS, nullptr },
        { "delete_data", reinterpret_cast<PyCFunction>(IXmlText_DeleteData), METH_VARARGS, nullptr },
        { "get_xml", reinterpret_cast<PyCFunction>(IXmlText_GetXml), METH_VARARGS, nullptr },
        { "has_child_nodes", reinterpret_cast<PyCFunction>(IXmlText_HasChildNodes), METH_VARARGS, nullptr },
        { "insert_before", reinterpret_cast<PyCFunction>(IXmlText_InsertBefore), METH_VARARGS, nullptr },
        { "insert_data", reinterpret_cast<PyCFunction>(IXmlText_InsertData), 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 },
        { "replace_data", reinterpret_cast<PyCFunction>(IXmlText_ReplaceData), 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 },
        { "split_text", reinterpret_cast<PyCFunction>(IXmlText_SplitText), METH_VARARGS, nullptr },
        { "substring_data", reinterpret_cast<PyCFunction>(IXmlText_SubstringData), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IXmlText, METH_O | METH_STATIC, 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, reinterpret_cast<void*>(_new_IXmlText) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IXmlText) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IXmlText) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IXmlText) },
        { },
    };

    static PyType_Spec type_spec_IXmlText =
    {
        "_toasts_winrt_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 --------------------
    PyDoc_STRVAR(module_doc, "Windows::Data::Xml::Dom");

    static PyMethodDef module_methods[] = {
        {"_register_NodeType", register_NodeType, METH_O, "registers type"},
        {}};


    static int module_traverse(PyObject* module, visitproc visit, void* arg) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_VISIT(state->type_NodeType);
        Py_VISIT(state->type_DtdEntity);
        Py_VISIT(state->type_DtdNotation);
        Py_VISIT(state->type_XmlAttribute);
        Py_VISIT(state->type_XmlCDataSection);
        Py_VISIT(state->type_XmlComment);
        Py_VISIT(state->type_XmlDocument);
        Py_VISIT(state->type_XmlDocumentFragment);
        Py_VISIT(state->type_XmlDocumentType);
        Py_VISIT(state->type_XmlDomImplementation);
        Py_VISIT(state->type_XmlElement);
        Py_VISIT(state->type_XmlEntityReference);
        Py_VISIT(state->type_XmlLoadSettings);
        Py_VISIT(state->type_XmlNamedNodeMap);
        Py_VISIT(state->type_XmlNodeList);
        Py_VISIT(state->type_XmlProcessingInstruction);
        Py_VISIT(state->type_XmlText);
        Py_VISIT(state->type_IXmlCharacterData);
        Py_VISIT(state->type_IXmlNode);
        Py_VISIT(state->type_IXmlNodeSelector);
        Py_VISIT(state->type_IXmlNodeSerializer);
        Py_VISIT(state->type_IXmlText);

        return 0;
    }

    static int module_clear(PyObject* module) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_CLEAR(state->type_NodeType);
        Py_CLEAR(state->type_DtdEntity);
        Py_CLEAR(state->type_DtdNotation);
        Py_CLEAR(state->type_XmlAttribute);
        Py_CLEAR(state->type_XmlCDataSection);
        Py_CLEAR(state->type_XmlComment);
        Py_CLEAR(state->type_XmlDocument);
        Py_CLEAR(state->type_XmlDocumentFragment);
        Py_CLEAR(state->type_XmlDocumentType);
        Py_CLEAR(state->type_XmlDomImplementation);
        Py_CLEAR(state->type_XmlElement);
        Py_CLEAR(state->type_XmlEntityReference);
        Py_CLEAR(state->type_XmlLoadSettings);
        Py_CLEAR(state->type_XmlNamedNodeMap);
        Py_CLEAR(state->type_XmlNodeList);
        Py_CLEAR(state->type_XmlProcessingInstruction);
        Py_CLEAR(state->type_XmlText);
        Py_CLEAR(state->type_IXmlCharacterData);
        Py_CLEAR(state->type_IXmlNode);
        Py_CLEAR(state->type_IXmlNodeSelector);
        Py_CLEAR(state->type_IXmlNodeSerializer);
        Py_CLEAR(state->type_IXmlText);

        return 0;
    }


    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_toasts_winrt_Windows_Data_Xml_Dom",
           module_doc,
           sizeof(module_state),
           module_methods,
           nullptr,
           module_traverse,
           module_clear,
           nullptr};

} // py::cpp::Windows::Data::Xml::Dom

PyMODINIT_FUNC PyInit__toasts_winrt_Windows_Data_Xml_Dom(void) noexcept
{
    using namespace py::cpp::Windows::Data::Xml::Dom;

    py::pyobj_handle module{PyModule_Create(&module_def)};

    if (!module)
    {
        return nullptr;
    }

    auto object_type = py::get_python_type<py::Object>();
    if (!object_type)
    {
        return nullptr;
    }

    py::pyobj_handle object_bases{PyTuple_Pack(1, object_type)};

    if (!object_bases)
    {
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module.get()));
    assert(state);

    state->type_DtdEntity = py::register_python_type(module.get(), type_name_DtdEntity, &type_spec_DtdEntity, object_bases.get(), nullptr);
    if (!state->type_DtdEntity)
    {
        return nullptr;
    }

    state->type_DtdNotation = py::register_python_type(module.get(), type_name_DtdNotation, &type_spec_DtdNotation, object_bases.get(), nullptr);
    if (!state->type_DtdNotation)
    {
        return nullptr;
    }

    state->type_XmlAttribute = py::register_python_type(module.get(), type_name_XmlAttribute, &type_spec_XmlAttribute, object_bases.get(), nullptr);
    if (!state->type_XmlAttribute)
    {
        return nullptr;
    }

    state->type_XmlCDataSection = py::register_python_type(module.get(), type_name_XmlCDataSection, &type_spec_XmlCDataSection, object_bases.get(), nullptr);
    if (!state->type_XmlCDataSection)
    {
        return nullptr;
    }

    state->type_XmlComment = py::register_python_type(module.get(), type_name_XmlComment, &type_spec_XmlComment, object_bases.get(), nullptr);
    if (!state->type_XmlComment)
    {
        return nullptr;
    }

    state->type_XmlDocument = py::register_python_type(module.get(), type_name_XmlDocument, &type_spec_XmlDocument, object_bases.get(), nullptr);
    if (!state->type_XmlDocument)
    {
        return nullptr;
    }

    state->type_XmlDocumentFragment = py::register_python_type(module.get(), type_name_XmlDocumentFragment, &type_spec_XmlDocumentFragment, object_bases.get(), nullptr);
    if (!state->type_XmlDocumentFragment)
    {
        return nullptr;
    }

    state->type_XmlDocumentType = py::register_python_type(module.get(), type_name_XmlDocumentType, &type_spec_XmlDocumentType, object_bases.get(), nullptr);
    if (!state->type_XmlDocumentType)
    {
        return nullptr;
    }

    state->type_XmlDomImplementation = py::register_python_type(module.get(), type_name_XmlDomImplementation, &type_spec_XmlDomImplementation, object_bases.get(), nullptr);
    if (!state->type_XmlDomImplementation)
    {
        return nullptr;
    }

    state->type_XmlElement = py::register_python_type(module.get(), type_name_XmlElement, &type_spec_XmlElement, object_bases.get(), nullptr);
    if (!state->type_XmlElement)
    {
        return nullptr;
    }

    state->type_XmlEntityReference = py::register_python_type(module.get(), type_name_XmlEntityReference, &type_spec_XmlEntityReference, object_bases.get(), nullptr);
    if (!state->type_XmlEntityReference)
    {
        return nullptr;
    }

    state->type_XmlLoadSettings = py::register_python_type(module.get(), type_name_XmlLoadSettings, &type_spec_XmlLoadSettings, object_bases.get(), nullptr);
    if (!state->type_XmlLoadSettings)
    {
        return nullptr;
    }

    state->type_XmlNamedNodeMap = py::register_python_type(module.get(), type_name_XmlNamedNodeMap, &type_spec_XmlNamedNodeMap, object_bases.get(), nullptr);
    if (!state->type_XmlNamedNodeMap)
    {
        return nullptr;
    }

    state->type_XmlNodeList = py::register_python_type(module.get(), type_name_XmlNodeList, &type_spec_XmlNodeList, object_bases.get(), nullptr);
    if (!state->type_XmlNodeList)
    {
        return nullptr;
    }

    state->type_XmlProcessingInstruction = py::register_python_type(module.get(), type_name_XmlProcessingInstruction, &type_spec_XmlProcessingInstruction, object_bases.get(), nullptr);
    if (!state->type_XmlProcessingInstruction)
    {
        return nullptr;
    }

    state->type_XmlText = py::register_python_type(module.get(), type_name_XmlText, &type_spec_XmlText, object_bases.get(), nullptr);
    if (!state->type_XmlText)
    {
        return nullptr;
    }

    state->type_IXmlCharacterData = py::register_python_type(module.get(), type_name_IXmlCharacterData, &type_spec_IXmlCharacterData, object_bases.get(), nullptr);
    if (!state->type_IXmlCharacterData)
    {
        return nullptr;
    }

    state->type_IXmlNode = py::register_python_type(module.get(), type_name_IXmlNode, &type_spec_IXmlNode, object_bases.get(), nullptr);
    if (!state->type_IXmlNode)
    {
        return nullptr;
    }

    state->type_IXmlNodeSelector = py::register_python_type(module.get(), type_name_IXmlNodeSelector, &type_spec_IXmlNodeSelector, object_bases.get(), nullptr);
    if (!state->type_IXmlNodeSelector)
    {
        return nullptr;
    }

    state->type_IXmlNodeSerializer = py::register_python_type(module.get(), type_name_IXmlNodeSerializer, &type_spec_IXmlNodeSerializer, object_bases.get(), nullptr);
    if (!state->type_IXmlNodeSerializer)
    {
        return nullptr;
    }

    state->type_IXmlText = py::register_python_type(module.get(), type_name_IXmlText, &type_spec_IXmlText, object_bases.get(), nullptr);
    if (!state->type_IXmlText)
    {
        return nullptr;
    }


    return module.detach();
}

PyObject* py::py_type<winrt::Windows::Data::Xml::Dom::NodeType>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_NodeType;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::NodeType is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::DtdEntity>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_DtdEntity;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::DtdEntity is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::DtdNotation>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_DtdNotation;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::DtdNotation is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlAttribute>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlAttribute;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlAttribute is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlCDataSection>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlCDataSection;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlCDataSection is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlComment>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlComment;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlComment is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocument>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlDocument;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlDocument is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocumentFragment>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlDocumentFragment;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlDocumentFragment is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDocumentType>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlDocumentType;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlDocumentType is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlDomImplementation>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlDomImplementation;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlDomImplementation is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlElement>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlElement;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlElement is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlEntityReference>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlEntityReference;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlEntityReference is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlLoadSettings>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlLoadSettings;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlLoadSettings is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlNamedNodeMap>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlNamedNodeMap;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlNamedNodeMap is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlNodeList>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlNodeList;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlNodeList is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlProcessingInstruction>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlProcessingInstruction;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlProcessingInstruction is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::XmlText>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_XmlText;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::XmlText is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlCharacterData>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_IXmlCharacterData;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::IXmlCharacterData is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNode>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_IXmlNode;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::IXmlNode is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNodeSelector>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_IXmlNodeSelector;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::IXmlNodeSelector is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlNodeSerializer>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_IXmlNodeSerializer;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::IXmlNodeSerializer is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Data::Xml::Dom::IXmlText>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Data::Xml::Dom;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Data::Xml::Dom");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_IXmlText;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Data::Xml::Dom::IXmlText is not registered");
        return nullptr;
    }

    return python_type;
}
