// WARNING: Please don't edit this file. It was generated by Python/WinRT v2.0.1

#include "py.Microsoft.UI.Xaml.Controls.h"


namespace py::cpp::Microsoft::UI::Xaml::Controls
{
    // ----- AnchorRequestedEventArgs class --------------------

    static PyObject* _new_AnchorRequestedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AnchorRequestedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnchorRequestedEventArgs_get_Anchor(py::wrapper::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnchorRequestedEventArgs", L"Anchor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnchorRequestedEventArgs_put_Anchor(py::wrapper::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnchorRequestedEventArgs", L"Anchor"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

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

    static PyObject* AnchorRequestedEventArgs_get_AnchorCandidates(py::wrapper::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnchorRequestedEventArgs", L"AnchorCandidates"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_AnchorRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnchorRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnchorRequestedEventArgs[] = {
        { "_assign_array_", _assign_array_AnchorRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnchorRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnchorRequestedEventArgs[] = {
        { "anchor", reinterpret_cast<getter>(AnchorRequestedEventArgs_get_Anchor), reinterpret_cast<setter>(AnchorRequestedEventArgs_put_Anchor), nullptr, nullptr },
        { "anchor_candidates", reinterpret_cast<getter>(AnchorRequestedEventArgs_get_AnchorCandidates), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnchorRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnchorRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnchorRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnchorRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnchorRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_AnchorRequestedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnchorRequestedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnchorRequestedEventArgs
    };

    // ----- AnimatedIcon class --------------------

    static PyObject* _new_AnimatedIcon(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::Microsoft::UI::Xaml::Controls::AnimatedIcon 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_AnimatedIcon(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnimatedIcon_GetState(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"GetState", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon::GetState(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* AnimatedIcon_SetState(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"SetState", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon::SetState(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* AnimatedIcon_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedIcon_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"Source"))
        {
            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::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2>(arg);

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

    static PyObject* AnimatedIcon_get_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"MirroredWhenRightToLeft"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedIcon_put_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"MirroredWhenRightToLeft"))
        {
            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.MirroredWhenRightToLeft(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AnimatedIcon_get_FallbackIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"FallbackIconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedIcon_put_FallbackIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"FallbackIconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

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

    static PyObject* AnimatedIcon_get_FallbackIconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"FallbackIconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon::FallbackIconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedIcon_get_MirroredWhenRightToLeftProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"MirroredWhenRightToLeftProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon::MirroredWhenRightToLeftProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedIcon_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedIcon_get_StateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIcon", L"StateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon::StateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AnimatedIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnimatedIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnimatedIcon>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnimatedIcon[] = {
        { "_assign_array_", _assign_array_AnimatedIcon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnimatedIcon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnimatedIcon[] = {
        { "source", reinterpret_cast<getter>(AnimatedIcon_get_Source), reinterpret_cast<setter>(AnimatedIcon_put_Source), nullptr, nullptr },
        { "mirrored_when_right_to_left", reinterpret_cast<getter>(AnimatedIcon_get_MirroredWhenRightToLeft), reinterpret_cast<setter>(AnimatedIcon_put_MirroredWhenRightToLeft), nullptr, nullptr },
        { "fallback_icon_source", reinterpret_cast<getter>(AnimatedIcon_get_FallbackIconSource), reinterpret_cast<setter>(AnimatedIcon_put_FallbackIconSource), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnimatedIcon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnimatedIcon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnimatedIcon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnimatedIcon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnimatedIcon) },
        { },
    };

    static PyType_Spec type_spec_AnimatedIcon =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnimatedIcon",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIcon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnimatedIcon
    };

    static PyGetSetDef getset_AnimatedIcon_Static[] = {
        { "fallback_icon_source_property", reinterpret_cast<getter>(AnimatedIcon_get_FallbackIconSourceProperty), nullptr, nullptr, nullptr },
        { "mirrored_when_right_to_left_property", reinterpret_cast<getter>(AnimatedIcon_get_MirroredWhenRightToLeftProperty), nullptr, nullptr, nullptr },
        { "source_property", reinterpret_cast<getter>(AnimatedIcon_get_SourceProperty), nullptr, nullptr, nullptr },
        { "state_property", reinterpret_cast<getter>(AnimatedIcon_get_StateProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AnimatedIcon_Static[] = {
        { "get_state", reinterpret_cast<PyCFunction>(AnimatedIcon_GetState), METH_VARARGS, nullptr },
        { "set_state", reinterpret_cast<PyCFunction>(AnimatedIcon_SetState), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_AnimatedIcon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AnimatedIcon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AnimatedIcon_Static) },
        { }
    };

    static PyType_Spec type_spec_AnimatedIcon_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnimatedIcon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AnimatedIcon_Static
    };

    // ----- AnimatedIconSource class --------------------

    static PyObject* _new_AnimatedIconSource(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::Microsoft::UI::Xaml::Controls::AnimatedIconSource 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_AnimatedIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnimatedIconSource_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedIconSource_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"Source"))
        {
            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::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2>(arg);

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

    static PyObject* AnimatedIconSource_get_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"MirroredWhenRightToLeft"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedIconSource_put_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"MirroredWhenRightToLeft"))
        {
            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.MirroredWhenRightToLeft(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AnimatedIconSource_get_FallbackIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"FallbackIconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedIconSource_put_FallbackIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"FallbackIconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

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

    static PyObject* AnimatedIconSource_get_FallbackIconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"FallbackIconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIconSource::FallbackIconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedIconSource_get_MirroredWhenRightToLeftProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"MirroredWhenRightToLeftProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIconSource::MirroredWhenRightToLeftProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedIconSource_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedIconSource", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedIconSource::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AnimatedIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnimatedIconSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnimatedIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnimatedIconSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnimatedIconSource[] = {
        { "_assign_array_", _assign_array_AnimatedIconSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnimatedIconSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnimatedIconSource[] = {
        { "source", reinterpret_cast<getter>(AnimatedIconSource_get_Source), reinterpret_cast<setter>(AnimatedIconSource_put_Source), nullptr, nullptr },
        { "mirrored_when_right_to_left", reinterpret_cast<getter>(AnimatedIconSource_get_MirroredWhenRightToLeft), reinterpret_cast<setter>(AnimatedIconSource_put_MirroredWhenRightToLeft), nullptr, nullptr },
        { "fallback_icon_source", reinterpret_cast<getter>(AnimatedIconSource_get_FallbackIconSource), reinterpret_cast<setter>(AnimatedIconSource_put_FallbackIconSource), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnimatedIconSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnimatedIconSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnimatedIconSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnimatedIconSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnimatedIconSource) },
        { },
    };

    static PyType_Spec type_spec_AnimatedIconSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnimatedIconSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedIconSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnimatedIconSource
    };

    static PyGetSetDef getset_AnimatedIconSource_Static[] = {
        { "fallback_icon_source_property", reinterpret_cast<getter>(AnimatedIconSource_get_FallbackIconSourceProperty), nullptr, nullptr, nullptr },
        { "mirrored_when_right_to_left_property", reinterpret_cast<getter>(AnimatedIconSource_get_MirroredWhenRightToLeftProperty), nullptr, nullptr, nullptr },
        { "source_property", reinterpret_cast<getter>(AnimatedIconSource_get_SourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AnimatedIconSource_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AnimatedIconSource_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AnimatedIconSource_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AnimatedIconSource_Static) },
        { }
    };

    static PyType_Spec type_spec_AnimatedIconSource_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnimatedIconSource_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AnimatedIconSource_Static
    };

    // ----- AnimatedVisualPlayer class --------------------

    static PyObject* _new_AnimatedVisualPlayer(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::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer 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_AnimatedVisualPlayer(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnimatedVisualPlayer_Pause(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Pause", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* AnimatedVisualPlayer_PlayAsync(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"PlayAsync", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);
                auto param2 = py::convert_to<bool>(args, 2);

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

    static PyObject* AnimatedVisualPlayer_Resume(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Resume", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* AnimatedVisualPlayer_SetProgress(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"SetProgress", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);

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

    static PyObject* AnimatedVisualPlayer_Stop(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Stop", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* AnimatedVisualPlayer_get_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Stretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedVisualPlayer_put_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Stretch"))
        {
            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::Microsoft::UI::Xaml::Media::Stretch>(arg);

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

    static PyObject* AnimatedVisualPlayer_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedVisualPlayer_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Source"))
        {
            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::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource>(arg);

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

    static PyObject* AnimatedVisualPlayer_get_PlaybackRate(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"PlaybackRate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedVisualPlayer_put_PlaybackRate(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"PlaybackRate"))
        {
            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<double>(arg);

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

    static PyObject* AnimatedVisualPlayer_get_FallbackContent(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"FallbackContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedVisualPlayer_put_FallbackContent(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"FallbackContent"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* AnimatedVisualPlayer_get_AutoPlay(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"AutoPlay"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedVisualPlayer_put_AutoPlay(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"AutoPlay"))
        {
            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.AutoPlay(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_Diagnostics(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Diagnostics"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnimatedVisualPlayer_get_Duration(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"Duration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnimatedVisualPlayer_get_IsAnimatedVisualLoaded(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"IsAnimatedVisualLoaded"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnimatedVisualPlayer_get_IsPlaying(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"IsPlaying"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnimatedVisualPlayer_get_ProgressObject(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"ProgressObject"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnimatedVisualPlayer_get_AnimationOptimization(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"AnimationOptimization"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnimatedVisualPlayer_put_AnimationOptimization(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"AnimationOptimization"))
        {
            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::Microsoft::UI::Xaml::Controls::PlayerAnimationOptimization>(arg);

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

    static PyObject* AnimatedVisualPlayer_get_AutoPlayProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"AutoPlayProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::AutoPlayProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_DiagnosticsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"DiagnosticsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::DiagnosticsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_DurationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"DurationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::DurationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_FallbackContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"FallbackContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::FallbackContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_IsAnimatedVisualLoadedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"IsAnimatedVisualLoadedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::IsAnimatedVisualLoadedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_IsPlayingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"IsPlayingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::IsPlayingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_PlaybackRateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"PlaybackRateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::PlaybackRateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_StretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"StretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::StretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnimatedVisualPlayer_get_AnimationOptimizationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer", L"AnimationOptimizationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer::AnimationOptimizationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AnimatedVisualPlayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnimatedVisualPlayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnimatedVisualPlayer[] = {
        { "pause", reinterpret_cast<PyCFunction>(AnimatedVisualPlayer_Pause), METH_VARARGS, nullptr },
        { "play_async", reinterpret_cast<PyCFunction>(AnimatedVisualPlayer_PlayAsync), METH_VARARGS, nullptr },
        { "resume", reinterpret_cast<PyCFunction>(AnimatedVisualPlayer_Resume), METH_VARARGS, nullptr },
        { "set_progress", reinterpret_cast<PyCFunction>(AnimatedVisualPlayer_SetProgress), METH_VARARGS, nullptr },
        { "stop", reinterpret_cast<PyCFunction>(AnimatedVisualPlayer_Stop), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AnimatedVisualPlayer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnimatedVisualPlayer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnimatedVisualPlayer[] = {
        { "stretch", reinterpret_cast<getter>(AnimatedVisualPlayer_get_Stretch), reinterpret_cast<setter>(AnimatedVisualPlayer_put_Stretch), nullptr, nullptr },
        { "source", reinterpret_cast<getter>(AnimatedVisualPlayer_get_Source), reinterpret_cast<setter>(AnimatedVisualPlayer_put_Source), nullptr, nullptr },
        { "playback_rate", reinterpret_cast<getter>(AnimatedVisualPlayer_get_PlaybackRate), reinterpret_cast<setter>(AnimatedVisualPlayer_put_PlaybackRate), nullptr, nullptr },
        { "fallback_content", reinterpret_cast<getter>(AnimatedVisualPlayer_get_FallbackContent), reinterpret_cast<setter>(AnimatedVisualPlayer_put_FallbackContent), nullptr, nullptr },
        { "auto_play", reinterpret_cast<getter>(AnimatedVisualPlayer_get_AutoPlay), reinterpret_cast<setter>(AnimatedVisualPlayer_put_AutoPlay), nullptr, nullptr },
        { "diagnostics", reinterpret_cast<getter>(AnimatedVisualPlayer_get_Diagnostics), nullptr, nullptr, nullptr },
        { "duration", reinterpret_cast<getter>(AnimatedVisualPlayer_get_Duration), nullptr, nullptr, nullptr },
        { "is_animated_visual_loaded", reinterpret_cast<getter>(AnimatedVisualPlayer_get_IsAnimatedVisualLoaded), nullptr, nullptr, nullptr },
        { "is_playing", reinterpret_cast<getter>(AnimatedVisualPlayer_get_IsPlaying), nullptr, nullptr, nullptr },
        { "progress_object", reinterpret_cast<getter>(AnimatedVisualPlayer_get_ProgressObject), nullptr, nullptr, nullptr },
        { "animation_optimization", reinterpret_cast<getter>(AnimatedVisualPlayer_get_AnimationOptimization), reinterpret_cast<setter>(AnimatedVisualPlayer_put_AnimationOptimization), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnimatedVisualPlayer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnimatedVisualPlayer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnimatedVisualPlayer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnimatedVisualPlayer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnimatedVisualPlayer) },
        { },
    };

    static PyType_Spec type_spec_AnimatedVisualPlayer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnimatedVisualPlayer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnimatedVisualPlayer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnimatedVisualPlayer
    };

    static PyGetSetDef getset_AnimatedVisualPlayer_Static[] = {
        { "auto_play_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_AutoPlayProperty), nullptr, nullptr, nullptr },
        { "diagnostics_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_DiagnosticsProperty), nullptr, nullptr, nullptr },
        { "duration_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_DurationProperty), nullptr, nullptr, nullptr },
        { "fallback_content_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_FallbackContentProperty), nullptr, nullptr, nullptr },
        { "is_animated_visual_loaded_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_IsAnimatedVisualLoadedProperty), nullptr, nullptr, nullptr },
        { "is_playing_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_IsPlayingProperty), nullptr, nullptr, nullptr },
        { "playback_rate_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_PlaybackRateProperty), nullptr, nullptr, nullptr },
        { "source_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_SourceProperty), nullptr, nullptr, nullptr },
        { "stretch_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_StretchProperty), nullptr, nullptr, nullptr },
        { "animation_optimization_property", reinterpret_cast<getter>(AnimatedVisualPlayer_get_AnimationOptimizationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AnimatedVisualPlayer_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AnimatedVisualPlayer_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AnimatedVisualPlayer_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AnimatedVisualPlayer_Static) },
        { }
    };

    static PyType_Spec type_spec_AnimatedVisualPlayer_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnimatedVisualPlayer_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AnimatedVisualPlayer_Static
    };

    // ----- AnnotatedScrollBar class --------------------

    static PyObject* _new_AnnotatedScrollBar(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::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar 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_AnnotatedScrollBar(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnnotatedScrollBar_get_SmallChange(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"SmallChange"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnnotatedScrollBar_put_SmallChange(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"SmallChange"))
        {
            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<double>(arg);

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

    static PyObject* AnnotatedScrollBar_get_Labels(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"Labels"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnnotatedScrollBar_put_Labels(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"Labels"))
        {
            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::Collections::IVector<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel>>(arg);

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

    static PyObject* AnnotatedScrollBar_get_LabelTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"LabelTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnnotatedScrollBar_put_LabelTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"LabelTemplate"))
        {
            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::Microsoft::UI::Xaml::IElementFactory>(arg);

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

    static PyObject* AnnotatedScrollBar_get_DetailLabelTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"DetailLabelTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnnotatedScrollBar_put_DetailLabelTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"DetailLabelTemplate"))
        {
            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::Microsoft::UI::Xaml::IElementFactory>(arg);

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

    static PyObject* AnnotatedScrollBar_get_ScrollController(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"ScrollController"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnnotatedScrollBar_get_DetailLabelTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"DetailLabelTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar::DetailLabelTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnnotatedScrollBar_get_LabelTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"LabelTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar::LabelTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnnotatedScrollBar_get_LabelsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"LabelsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar::LabelsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnnotatedScrollBar_get_SmallChangeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"SmallChangeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar::SmallChangeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnnotatedScrollBar_add_DetailLabelRequested(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"DetailLabelRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar, winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs>>(arg);

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

    static PyObject* AnnotatedScrollBar_remove_DetailLabelRequested(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"DetailLabelRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AnnotatedScrollBar_add_Scrolling(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"Scrolling"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar, winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs>>(arg);

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

    static PyObject* AnnotatedScrollBar_remove_Scrolling(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBar", L"Scrolling"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_AnnotatedScrollBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnnotatedScrollBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnnotatedScrollBar[] = {
        { "add_detail_label_requested", reinterpret_cast<PyCFunction>(AnnotatedScrollBar_add_DetailLabelRequested), METH_O, nullptr },
        { "remove_detail_label_requested", reinterpret_cast<PyCFunction>(AnnotatedScrollBar_remove_DetailLabelRequested), METH_O, nullptr },
        { "add_scrolling", reinterpret_cast<PyCFunction>(AnnotatedScrollBar_add_Scrolling), METH_O, nullptr },
        { "remove_scrolling", reinterpret_cast<PyCFunction>(AnnotatedScrollBar_remove_Scrolling), METH_O, nullptr },
        { "_assign_array_", _assign_array_AnnotatedScrollBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnnotatedScrollBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnnotatedScrollBar[] = {
        { "small_change", reinterpret_cast<getter>(AnnotatedScrollBar_get_SmallChange), reinterpret_cast<setter>(AnnotatedScrollBar_put_SmallChange), nullptr, nullptr },
        { "labels", reinterpret_cast<getter>(AnnotatedScrollBar_get_Labels), reinterpret_cast<setter>(AnnotatedScrollBar_put_Labels), nullptr, nullptr },
        { "label_template", reinterpret_cast<getter>(AnnotatedScrollBar_get_LabelTemplate), reinterpret_cast<setter>(AnnotatedScrollBar_put_LabelTemplate), nullptr, nullptr },
        { "detail_label_template", reinterpret_cast<getter>(AnnotatedScrollBar_get_DetailLabelTemplate), reinterpret_cast<setter>(AnnotatedScrollBar_put_DetailLabelTemplate), nullptr, nullptr },
        { "scroll_controller", reinterpret_cast<getter>(AnnotatedScrollBar_get_ScrollController), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnnotatedScrollBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnnotatedScrollBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnnotatedScrollBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnnotatedScrollBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnnotatedScrollBar) },
        { },
    };

    static PyType_Spec type_spec_AnnotatedScrollBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnnotatedScrollBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnnotatedScrollBar
    };

    static PyGetSetDef getset_AnnotatedScrollBar_Static[] = {
        { "detail_label_template_property", reinterpret_cast<getter>(AnnotatedScrollBar_get_DetailLabelTemplateProperty), nullptr, nullptr, nullptr },
        { "label_template_property", reinterpret_cast<getter>(AnnotatedScrollBar_get_LabelTemplateProperty), nullptr, nullptr, nullptr },
        { "labels_property", reinterpret_cast<getter>(AnnotatedScrollBar_get_LabelsProperty), nullptr, nullptr, nullptr },
        { "small_change_property", reinterpret_cast<getter>(AnnotatedScrollBar_get_SmallChangeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AnnotatedScrollBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AnnotatedScrollBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AnnotatedScrollBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AnnotatedScrollBar_Static) },
        { }
    };

    static PyType_Spec type_spec_AnnotatedScrollBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnnotatedScrollBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AnnotatedScrollBar_Static
    };

    // ----- AnnotatedScrollBarDetailLabelRequestedEventArgs class --------------------

    static PyObject* _new_AnnotatedScrollBarDetailLabelRequestedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AnnotatedScrollBarDetailLabelRequestedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnnotatedScrollBarDetailLabelRequestedEventArgs_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarDetailLabelRequestedEventArgs", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnnotatedScrollBarDetailLabelRequestedEventArgs_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarDetailLabelRequestedEventArgs", L"Content"))
        {
            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.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AnnotatedScrollBarDetailLabelRequestedEventArgs_get_ScrollOffset(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarDetailLabelRequestedEventArgs", L"ScrollOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_AnnotatedScrollBarDetailLabelRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnnotatedScrollBarDetailLabelRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnnotatedScrollBarDetailLabelRequestedEventArgs[] = {
        { "_assign_array_", _assign_array_AnnotatedScrollBarDetailLabelRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnnotatedScrollBarDetailLabelRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnnotatedScrollBarDetailLabelRequestedEventArgs[] = {
        { "content", reinterpret_cast<getter>(AnnotatedScrollBarDetailLabelRequestedEventArgs_get_Content), reinterpret_cast<setter>(AnnotatedScrollBarDetailLabelRequestedEventArgs_put_Content), nullptr, nullptr },
        { "scroll_offset", reinterpret_cast<getter>(AnnotatedScrollBarDetailLabelRequestedEventArgs_get_ScrollOffset), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnnotatedScrollBarDetailLabelRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnnotatedScrollBarDetailLabelRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnnotatedScrollBarDetailLabelRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnnotatedScrollBarDetailLabelRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnnotatedScrollBarDetailLabelRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_AnnotatedScrollBarDetailLabelRequestedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnnotatedScrollBarDetailLabelRequestedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarDetailLabelRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnnotatedScrollBarDetailLabelRequestedEventArgs
    };

    // ----- AnnotatedScrollBarLabel class --------------------

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

                winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel instance{ param0, param1 };
                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_AnnotatedScrollBarLabel(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnnotatedScrollBarLabel_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarLabel", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnnotatedScrollBarLabel_get_ScrollOffset(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarLabel", L"ScrollOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_AnnotatedScrollBarLabel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnnotatedScrollBarLabel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnnotatedScrollBarLabel[] = {
        { "_assign_array_", _assign_array_AnnotatedScrollBarLabel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnnotatedScrollBarLabel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnnotatedScrollBarLabel[] = {
        { "content", reinterpret_cast<getter>(AnnotatedScrollBarLabel_get_Content), nullptr, nullptr, nullptr },
        { "scroll_offset", reinterpret_cast<getter>(AnnotatedScrollBarLabel_get_ScrollOffset), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnnotatedScrollBarLabel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnnotatedScrollBarLabel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnnotatedScrollBarLabel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnnotatedScrollBarLabel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnnotatedScrollBarLabel) },
        { },
    };

    static PyType_Spec type_spec_AnnotatedScrollBarLabel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnnotatedScrollBarLabel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarLabel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnnotatedScrollBarLabel
    };

    // ----- AnnotatedScrollBarScrollingEventArgs class --------------------

    static PyObject* _new_AnnotatedScrollBarScrollingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_AnnotatedScrollBarScrollingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AnnotatedScrollBarScrollingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarScrollingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AnnotatedScrollBarScrollingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarScrollingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AnnotatedScrollBarScrollingEventArgs_get_ScrollOffset(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarScrollingEventArgs", L"ScrollOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AnnotatedScrollBarScrollingEventArgs_get_ScrollingEventKind(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AnnotatedScrollBarScrollingEventArgs", L"ScrollingEventKind"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_AnnotatedScrollBarScrollingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AnnotatedScrollBarScrollingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnnotatedScrollBarScrollingEventArgs[] = {
        { "_assign_array_", _assign_array_AnnotatedScrollBarScrollingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AnnotatedScrollBarScrollingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnnotatedScrollBarScrollingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(AnnotatedScrollBarScrollingEventArgs_get_Cancel), reinterpret_cast<setter>(AnnotatedScrollBarScrollingEventArgs_put_Cancel), nullptr, nullptr },
        { "scroll_offset", reinterpret_cast<getter>(AnnotatedScrollBarScrollingEventArgs_get_ScrollOffset), nullptr, nullptr, nullptr },
        { "scrolling_event_kind", reinterpret_cast<getter>(AnnotatedScrollBarScrollingEventArgs_get_ScrollingEventKind), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnnotatedScrollBarScrollingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AnnotatedScrollBarScrollingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AnnotatedScrollBarScrollingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AnnotatedScrollBarScrollingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AnnotatedScrollBarScrollingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_AnnotatedScrollBarScrollingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AnnotatedScrollBarScrollingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AnnotatedScrollBarScrollingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnnotatedScrollBarScrollingEventArgs
    };

    // ----- AppBar class --------------------

    static PyObject* _new_AppBar(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::Microsoft::UI::Xaml::Controls::AppBar 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_AppBar(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppBar_get_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"LightDismissOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBar_put_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"LightDismissOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::LightDismissOverlayMode>(arg);

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

    static PyObject* AppBar_get_IsSticky(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"IsSticky"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBar_put_IsSticky(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"IsSticky"))
        {
            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.IsSticky(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBar_get_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"IsOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBar_put_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"IsOpen"))
        {
            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.IsOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBar_get_ClosedDisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"ClosedDisplayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBar_put_ClosedDisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"ClosedDisplayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::AppBarClosedDisplayMode>(arg);

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

    static PyObject* AppBar_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AppBar_get_ClosedDisplayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"ClosedDisplayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBar::ClosedDisplayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBar_get_IsOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"IsOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBar::IsOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBar_get_IsStickyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"IsStickyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBar::IsStickyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBar_get_LightDismissOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"LightDismissOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBar::LightDismissOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBar_add_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AppBar_remove_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AppBar_add_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AppBar_remove_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AppBar_add_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AppBar_remove_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AppBar_add_Opening(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Opening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AppBar_remove_Opening(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AppBar", L"Opening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_AppBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AppBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AppBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppBar[] = {
        { "add_closed", reinterpret_cast<PyCFunction>(AppBar_add_Closed), METH_O, nullptr },
        { "remove_closed", reinterpret_cast<PyCFunction>(AppBar_remove_Closed), METH_O, nullptr },
        { "add_closing", reinterpret_cast<PyCFunction>(AppBar_add_Closing), METH_O, nullptr },
        { "remove_closing", reinterpret_cast<PyCFunction>(AppBar_remove_Closing), METH_O, nullptr },
        { "add_opened", reinterpret_cast<PyCFunction>(AppBar_add_Opened), METH_O, nullptr },
        { "remove_opened", reinterpret_cast<PyCFunction>(AppBar_remove_Opened), METH_O, nullptr },
        { "add_opening", reinterpret_cast<PyCFunction>(AppBar_add_Opening), METH_O, nullptr },
        { "remove_opening", reinterpret_cast<PyCFunction>(AppBar_remove_Opening), METH_O, nullptr },
        { "_assign_array_", _assign_array_AppBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AppBar[] = {
        { "light_dismiss_overlay_mode", reinterpret_cast<getter>(AppBar_get_LightDismissOverlayMode), reinterpret_cast<setter>(AppBar_put_LightDismissOverlayMode), nullptr, nullptr },
        { "is_sticky", reinterpret_cast<getter>(AppBar_get_IsSticky), reinterpret_cast<setter>(AppBar_put_IsSticky), nullptr, nullptr },
        { "is_open", reinterpret_cast<getter>(AppBar_get_IsOpen), reinterpret_cast<setter>(AppBar_put_IsOpen), nullptr, nullptr },
        { "closed_display_mode", reinterpret_cast<getter>(AppBar_get_ClosedDisplayMode), reinterpret_cast<setter>(AppBar_put_ClosedDisplayMode), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(AppBar_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AppBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppBar) },
        { },
    };

    static PyType_Spec type_spec_AppBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AppBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppBar
    };

    static PyGetSetDef getset_AppBar_Static[] = {
        { "closed_display_mode_property", reinterpret_cast<getter>(AppBar_get_ClosedDisplayModeProperty), nullptr, nullptr, nullptr },
        { "is_open_property", reinterpret_cast<getter>(AppBar_get_IsOpenProperty), nullptr, nullptr, nullptr },
        { "is_sticky_property", reinterpret_cast<getter>(AppBar_get_IsStickyProperty), nullptr, nullptr, nullptr },
        { "light_dismiss_overlay_mode_property", reinterpret_cast<getter>(AppBar_get_LightDismissOverlayModeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AppBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AppBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AppBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AppBar_Static) },
        { }
    };

    static PyType_Spec type_spec_AppBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AppBar_Static
    };

    // ----- AppBarButton class --------------------

    static PyObject* _new_AppBarButton(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::Microsoft::UI::Xaml::Controls::AppBarButton 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_AppBarButton(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppBarButton_get_LabelPosition(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"LabelPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarButton_put_LabelPosition(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"LabelPosition"))
        {
            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::Microsoft::UI::Xaml::Controls::CommandBarLabelPosition>(arg);

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

    static PyObject* AppBarButton_get_Label(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"Label"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarButton_put_Label(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"Label"))
        {
            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.Label(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarButton_get_KeyboardAcceleratorTextOverride(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"KeyboardAcceleratorTextOverride"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarButton_put_KeyboardAcceleratorTextOverride(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"KeyboardAcceleratorTextOverride"))
        {
            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.KeyboardAcceleratorTextOverride(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarButton_get_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"Icon"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarButton_put_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"Icon"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

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

    static PyObject* AppBarButton_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AppBarButton_get_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"IsCompact"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarButton_put_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"IsCompact"))
        {
            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.IsCompact(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarButton_get_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"DynamicOverflowOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarButton_put_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"DynamicOverflowOrder"))
        {
            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<int32_t>(arg);

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

    static PyObject* AppBarButton_get_IsInOverflow(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"IsInOverflow"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AppBarButton_get_DynamicOverflowOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"DynamicOverflowOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarButton::DynamicOverflowOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarButton_get_IconProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"IconProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarButton::IconProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarButton_get_IsCompactProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"IsCompactProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarButton::IsCompactProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarButton_get_IsInOverflowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"IsInOverflowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarButton::IsInOverflowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarButton_get_KeyboardAcceleratorTextOverrideProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"KeyboardAcceleratorTextOverrideProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarButton::KeyboardAcceleratorTextOverrideProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarButton_get_LabelPositionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"LabelPositionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarButton::LabelPositionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarButton_get_LabelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarButton", L"LabelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarButton::LabelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AppBarButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AppBarButton>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppBarButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AppBarButton>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppBarButton[] = {
        { "_assign_array_", _assign_array_AppBarButton, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppBarButton), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AppBarButton[] = {
        { "label_position", reinterpret_cast<getter>(AppBarButton_get_LabelPosition), reinterpret_cast<setter>(AppBarButton_put_LabelPosition), nullptr, nullptr },
        { "label", reinterpret_cast<getter>(AppBarButton_get_Label), reinterpret_cast<setter>(AppBarButton_put_Label), nullptr, nullptr },
        { "keyboard_accelerator_text_override", reinterpret_cast<getter>(AppBarButton_get_KeyboardAcceleratorTextOverride), reinterpret_cast<setter>(AppBarButton_put_KeyboardAcceleratorTextOverride), nullptr, nullptr },
        { "icon", reinterpret_cast<getter>(AppBarButton_get_Icon), reinterpret_cast<setter>(AppBarButton_put_Icon), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(AppBarButton_get_TemplateSettings), nullptr, nullptr, nullptr },
        { "is_compact", reinterpret_cast<getter>(AppBarButton_get_IsCompact), reinterpret_cast<setter>(AppBarButton_put_IsCompact), nullptr, nullptr },
        { "dynamic_overflow_order", reinterpret_cast<getter>(AppBarButton_get_DynamicOverflowOrder), reinterpret_cast<setter>(AppBarButton_put_DynamicOverflowOrder), nullptr, nullptr },
        { "is_in_overflow", reinterpret_cast<getter>(AppBarButton_get_IsInOverflow), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AppBarButton[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppBarButton) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppBarButton) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppBarButton) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppBarButton) },
        { },
    };

    static PyType_Spec type_spec_AppBarButton =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarButton",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarButton),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppBarButton
    };

    static PyGetSetDef getset_AppBarButton_Static[] = {
        { "dynamic_overflow_order_property", reinterpret_cast<getter>(AppBarButton_get_DynamicOverflowOrderProperty), nullptr, nullptr, nullptr },
        { "icon_property", reinterpret_cast<getter>(AppBarButton_get_IconProperty), nullptr, nullptr, nullptr },
        { "is_compact_property", reinterpret_cast<getter>(AppBarButton_get_IsCompactProperty), nullptr, nullptr, nullptr },
        { "is_in_overflow_property", reinterpret_cast<getter>(AppBarButton_get_IsInOverflowProperty), nullptr, nullptr, nullptr },
        { "keyboard_accelerator_text_override_property", reinterpret_cast<getter>(AppBarButton_get_KeyboardAcceleratorTextOverrideProperty), nullptr, nullptr, nullptr },
        { "label_position_property", reinterpret_cast<getter>(AppBarButton_get_LabelPositionProperty), nullptr, nullptr, nullptr },
        { "label_property", reinterpret_cast<getter>(AppBarButton_get_LabelProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AppBarButton_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AppBarButton_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AppBarButton_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AppBarButton_Static) },
        { }
    };

    static PyType_Spec type_spec_AppBarButton_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarButton_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AppBarButton_Static
    };

    // ----- AppBarElementContainer class --------------------

    static PyObject* _new_AppBarElementContainer(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::Microsoft::UI::Xaml::Controls::AppBarElementContainer 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_AppBarElementContainer(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarElementContainer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppBarElementContainer_get_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarElementContainer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"IsCompact"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarElementContainer_put_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarElementContainer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"IsCompact"))
        {
            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.IsCompact(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarElementContainer_get_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarElementContainer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"DynamicOverflowOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarElementContainer_put_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarElementContainer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"DynamicOverflowOrder"))
        {
            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<int32_t>(arg);

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

    static PyObject* AppBarElementContainer_get_IsInOverflow(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarElementContainer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"IsInOverflow"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AppBarElementContainer_get_DynamicOverflowOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"DynamicOverflowOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarElementContainer::DynamicOverflowOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarElementContainer_get_IsCompactProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"IsCompactProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarElementContainer::IsCompactProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarElementContainer_get_IsInOverflowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarElementContainer", L"IsInOverflowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarElementContainer::IsInOverflowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AppBarElementContainer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AppBarElementContainer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppBarElementContainer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AppBarElementContainer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppBarElementContainer[] = {
        { "_assign_array_", _assign_array_AppBarElementContainer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppBarElementContainer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AppBarElementContainer[] = {
        { "is_compact", reinterpret_cast<getter>(AppBarElementContainer_get_IsCompact), reinterpret_cast<setter>(AppBarElementContainer_put_IsCompact), nullptr, nullptr },
        { "dynamic_overflow_order", reinterpret_cast<getter>(AppBarElementContainer_get_DynamicOverflowOrder), reinterpret_cast<setter>(AppBarElementContainer_put_DynamicOverflowOrder), nullptr, nullptr },
        { "is_in_overflow", reinterpret_cast<getter>(AppBarElementContainer_get_IsInOverflow), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AppBarElementContainer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppBarElementContainer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppBarElementContainer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppBarElementContainer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppBarElementContainer) },
        { },
    };

    static PyType_Spec type_spec_AppBarElementContainer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarElementContainer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarElementContainer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppBarElementContainer
    };

    static PyGetSetDef getset_AppBarElementContainer_Static[] = {
        { "dynamic_overflow_order_property", reinterpret_cast<getter>(AppBarElementContainer_get_DynamicOverflowOrderProperty), nullptr, nullptr, nullptr },
        { "is_compact_property", reinterpret_cast<getter>(AppBarElementContainer_get_IsCompactProperty), nullptr, nullptr, nullptr },
        { "is_in_overflow_property", reinterpret_cast<getter>(AppBarElementContainer_get_IsInOverflowProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AppBarElementContainer_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AppBarElementContainer_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AppBarElementContainer_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AppBarElementContainer_Static) },
        { }
    };

    static PyType_Spec type_spec_AppBarElementContainer_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarElementContainer_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AppBarElementContainer_Static
    };

    // ----- AppBarSeparator class --------------------

    static PyObject* _new_AppBarSeparator(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::Microsoft::UI::Xaml::Controls::AppBarSeparator 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_AppBarSeparator(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarSeparator* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppBarSeparator_get_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarSeparator* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"IsCompact"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarSeparator_put_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarSeparator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"IsCompact"))
        {
            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.IsCompact(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarSeparator_get_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarSeparator* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"DynamicOverflowOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarSeparator_put_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarSeparator* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"DynamicOverflowOrder"))
        {
            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<int32_t>(arg);

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

    static PyObject* AppBarSeparator_get_IsInOverflow(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarSeparator* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"IsInOverflow"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AppBarSeparator_get_DynamicOverflowOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"DynamicOverflowOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarSeparator::DynamicOverflowOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarSeparator_get_IsCompactProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"IsCompactProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarSeparator::IsCompactProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarSeparator_get_IsInOverflowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarSeparator", L"IsInOverflowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarSeparator::IsInOverflowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AppBarSeparator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AppBarSeparator>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppBarSeparator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AppBarSeparator>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppBarSeparator[] = {
        { "_assign_array_", _assign_array_AppBarSeparator, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppBarSeparator), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AppBarSeparator[] = {
        { "is_compact", reinterpret_cast<getter>(AppBarSeparator_get_IsCompact), reinterpret_cast<setter>(AppBarSeparator_put_IsCompact), nullptr, nullptr },
        { "dynamic_overflow_order", reinterpret_cast<getter>(AppBarSeparator_get_DynamicOverflowOrder), reinterpret_cast<setter>(AppBarSeparator_put_DynamicOverflowOrder), nullptr, nullptr },
        { "is_in_overflow", reinterpret_cast<getter>(AppBarSeparator_get_IsInOverflow), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AppBarSeparator[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppBarSeparator) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppBarSeparator) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppBarSeparator) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppBarSeparator) },
        { },
    };

    static PyType_Spec type_spec_AppBarSeparator =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarSeparator",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarSeparator),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppBarSeparator
    };

    static PyGetSetDef getset_AppBarSeparator_Static[] = {
        { "dynamic_overflow_order_property", reinterpret_cast<getter>(AppBarSeparator_get_DynamicOverflowOrderProperty), nullptr, nullptr, nullptr },
        { "is_compact_property", reinterpret_cast<getter>(AppBarSeparator_get_IsCompactProperty), nullptr, nullptr, nullptr },
        { "is_in_overflow_property", reinterpret_cast<getter>(AppBarSeparator_get_IsInOverflowProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AppBarSeparator_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AppBarSeparator_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AppBarSeparator_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AppBarSeparator_Static) },
        { }
    };

    static PyType_Spec type_spec_AppBarSeparator_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarSeparator_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AppBarSeparator_Static
    };

    // ----- AppBarToggleButton class --------------------

    static PyObject* _new_AppBarToggleButton(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::Microsoft::UI::Xaml::Controls::AppBarToggleButton 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_AppBarToggleButton(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AppBarToggleButton_get_LabelPosition(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"LabelPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarToggleButton_put_LabelPosition(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"LabelPosition"))
        {
            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::Microsoft::UI::Xaml::Controls::CommandBarLabelPosition>(arg);

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

    static PyObject* AppBarToggleButton_get_Label(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"Label"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarToggleButton_put_Label(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"Label"))
        {
            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.Label(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarToggleButton_get_KeyboardAcceleratorTextOverride(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"KeyboardAcceleratorTextOverride"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarToggleButton_put_KeyboardAcceleratorTextOverride(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"KeyboardAcceleratorTextOverride"))
        {
            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.KeyboardAcceleratorTextOverride(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarToggleButton_get_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"Icon"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarToggleButton_put_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"Icon"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

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

    static PyObject* AppBarToggleButton_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AppBarToggleButton_get_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"IsCompact"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarToggleButton_put_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"IsCompact"))
        {
            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.IsCompact(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AppBarToggleButton_get_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"DynamicOverflowOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AppBarToggleButton_put_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"DynamicOverflowOrder"))
        {
            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<int32_t>(arg);

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

    static PyObject* AppBarToggleButton_get_IsInOverflow(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"IsInOverflow"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AppBarToggleButton_get_DynamicOverflowOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"DynamicOverflowOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton::DynamicOverflowOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarToggleButton_get_IconProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"IconProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton::IconProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarToggleButton_get_IsCompactProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"IsCompactProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton::IsCompactProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarToggleButton_get_IsInOverflowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"IsInOverflowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton::IsInOverflowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarToggleButton_get_KeyboardAcceleratorTextOverrideProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"KeyboardAcceleratorTextOverrideProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton::KeyboardAcceleratorTextOverrideProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarToggleButton_get_LabelPositionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"LabelPositionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton::LabelPositionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AppBarToggleButton_get_LabelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AppBarToggleButton", L"LabelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton::LabelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AppBarToggleButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AppBarToggleButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AppBarToggleButton>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppBarToggleButton[] = {
        { "_assign_array_", _assign_array_AppBarToggleButton, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AppBarToggleButton), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AppBarToggleButton[] = {
        { "label_position", reinterpret_cast<getter>(AppBarToggleButton_get_LabelPosition), reinterpret_cast<setter>(AppBarToggleButton_put_LabelPosition), nullptr, nullptr },
        { "label", reinterpret_cast<getter>(AppBarToggleButton_get_Label), reinterpret_cast<setter>(AppBarToggleButton_put_Label), nullptr, nullptr },
        { "keyboard_accelerator_text_override", reinterpret_cast<getter>(AppBarToggleButton_get_KeyboardAcceleratorTextOverride), reinterpret_cast<setter>(AppBarToggleButton_put_KeyboardAcceleratorTextOverride), nullptr, nullptr },
        { "icon", reinterpret_cast<getter>(AppBarToggleButton_get_Icon), reinterpret_cast<setter>(AppBarToggleButton_put_Icon), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(AppBarToggleButton_get_TemplateSettings), nullptr, nullptr, nullptr },
        { "is_compact", reinterpret_cast<getter>(AppBarToggleButton_get_IsCompact), reinterpret_cast<setter>(AppBarToggleButton_put_IsCompact), nullptr, nullptr },
        { "dynamic_overflow_order", reinterpret_cast<getter>(AppBarToggleButton_get_DynamicOverflowOrder), reinterpret_cast<setter>(AppBarToggleButton_put_DynamicOverflowOrder), nullptr, nullptr },
        { "is_in_overflow", reinterpret_cast<getter>(AppBarToggleButton_get_IsInOverflow), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AppBarToggleButton[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AppBarToggleButton) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AppBarToggleButton) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AppBarToggleButton) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AppBarToggleButton) },
        { },
    };

    static PyType_Spec type_spec_AppBarToggleButton =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarToggleButton",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AppBarToggleButton),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppBarToggleButton
    };

    static PyGetSetDef getset_AppBarToggleButton_Static[] = {
        { "dynamic_overflow_order_property", reinterpret_cast<getter>(AppBarToggleButton_get_DynamicOverflowOrderProperty), nullptr, nullptr, nullptr },
        { "icon_property", reinterpret_cast<getter>(AppBarToggleButton_get_IconProperty), nullptr, nullptr, nullptr },
        { "is_compact_property", reinterpret_cast<getter>(AppBarToggleButton_get_IsCompactProperty), nullptr, nullptr, nullptr },
        { "is_in_overflow_property", reinterpret_cast<getter>(AppBarToggleButton_get_IsInOverflowProperty), nullptr, nullptr, nullptr },
        { "keyboard_accelerator_text_override_property", reinterpret_cast<getter>(AppBarToggleButton_get_KeyboardAcceleratorTextOverrideProperty), nullptr, nullptr, nullptr },
        { "label_position_property", reinterpret_cast<getter>(AppBarToggleButton_get_LabelPositionProperty), nullptr, nullptr, nullptr },
        { "label_property", reinterpret_cast<getter>(AppBarToggleButton_get_LabelProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AppBarToggleButton_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AppBarToggleButton_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AppBarToggleButton_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AppBarToggleButton_Static) },
        { }
    };

    static PyType_Spec type_spec_AppBarToggleButton_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AppBarToggleButton_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AppBarToggleButton_Static
    };

    // ----- AutoSuggestBox class --------------------

    static PyObject* _new_AutoSuggestBox(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::Microsoft::UI::Xaml::Controls::AutoSuggestBox 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_AutoSuggestBox(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AutoSuggestBox_get_UpdateTextOnSelect(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"UpdateTextOnSelect"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_UpdateTextOnSelect(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"UpdateTextOnSelect"))
        {
            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.UpdateTextOnSelect(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_TextMemberPath(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextMemberPath"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_TextMemberPath(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextMemberPath"))
        {
            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.TextMemberPath(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_TextBoxStyle(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextBoxStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_TextBoxStyle(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextBoxStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* AutoSuggestBox_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_QueryIcon(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"QueryIcon"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_QueryIcon(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"QueryIcon"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

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

    static PyObject* AutoSuggestBox_get_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"PlaceholderText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"PlaceholderText"))
        {
            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.PlaceholderText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_MaxSuggestionListHeight(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"MaxSuggestionListHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_MaxSuggestionListHeight(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"MaxSuggestionListHeight"))
        {
            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<double>(arg);

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

    static PyObject* AutoSuggestBox_get_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"LightDismissOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"LightDismissOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::LightDismissOverlayMode>(arg);

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

    static PyObject* AutoSuggestBox_get_IsSuggestionListOpen(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"IsSuggestionListOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_IsSuggestionListOpen(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"IsSuggestionListOpen"))
        {
            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.IsSuggestionListOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_Description(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"Description"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_Description(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"Description"))
        {
            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.Description(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_AutoMaximizeSuggestionArea(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"AutoMaximizeSuggestionArea"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBox_put_AutoMaximizeSuggestionArea(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"AutoMaximizeSuggestionArea"))
        {
            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.AutoMaximizeSuggestionArea(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* AutoSuggestBox_get_AutoMaximizeSuggestionAreaProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"AutoMaximizeSuggestionAreaProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::AutoMaximizeSuggestionAreaProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_DescriptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"DescriptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::DescriptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_IsSuggestionListOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"IsSuggestionListOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::IsSuggestionListOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_LightDismissOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"LightDismissOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::LightDismissOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_MaxSuggestionListHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"MaxSuggestionListHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::MaxSuggestionListHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_PlaceholderTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"PlaceholderTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::PlaceholderTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_QueryIconProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"QueryIconProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::QueryIconProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_TextBoxStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextBoxStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::TextBoxStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_TextMemberPathProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextMemberPathProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::TextMemberPathProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_get_UpdateTextOnSelectProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"UpdateTextOnSelectProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox::UpdateTextOnSelectProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AutoSuggestBox_add_QuerySubmitted(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"QuerySubmitted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox, winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs>>(arg);

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

    static PyObject* AutoSuggestBox_remove_QuerySubmitted(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"QuerySubmitted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AutoSuggestBox_add_SuggestionChosen(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"SuggestionChosen"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox, winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxSuggestionChosenEventArgs>>(arg);

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

    static PyObject* AutoSuggestBox_remove_SuggestionChosen(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"SuggestionChosen"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* AutoSuggestBox_add_TextChanged(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox, winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs>>(arg);

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

    static PyObject* AutoSuggestBox_remove_TextChanged(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBox", L"TextChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_AutoSuggestBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AutoSuggestBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AutoSuggestBox[] = {
        { "add_query_submitted", reinterpret_cast<PyCFunction>(AutoSuggestBox_add_QuerySubmitted), METH_O, nullptr },
        { "remove_query_submitted", reinterpret_cast<PyCFunction>(AutoSuggestBox_remove_QuerySubmitted), METH_O, nullptr },
        { "add_suggestion_chosen", reinterpret_cast<PyCFunction>(AutoSuggestBox_add_SuggestionChosen), METH_O, nullptr },
        { "remove_suggestion_chosen", reinterpret_cast<PyCFunction>(AutoSuggestBox_remove_SuggestionChosen), METH_O, nullptr },
        { "add_text_changed", reinterpret_cast<PyCFunction>(AutoSuggestBox_add_TextChanged), METH_O, nullptr },
        { "remove_text_changed", reinterpret_cast<PyCFunction>(AutoSuggestBox_remove_TextChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_AutoSuggestBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AutoSuggestBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AutoSuggestBox[] = {
        { "update_text_on_select", reinterpret_cast<getter>(AutoSuggestBox_get_UpdateTextOnSelect), reinterpret_cast<setter>(AutoSuggestBox_put_UpdateTextOnSelect), nullptr, nullptr },
        { "text_member_path", reinterpret_cast<getter>(AutoSuggestBox_get_TextMemberPath), reinterpret_cast<setter>(AutoSuggestBox_put_TextMemberPath), nullptr, nullptr },
        { "text_box_style", reinterpret_cast<getter>(AutoSuggestBox_get_TextBoxStyle), reinterpret_cast<setter>(AutoSuggestBox_put_TextBoxStyle), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(AutoSuggestBox_get_Text), reinterpret_cast<setter>(AutoSuggestBox_put_Text), nullptr, nullptr },
        { "query_icon", reinterpret_cast<getter>(AutoSuggestBox_get_QueryIcon), reinterpret_cast<setter>(AutoSuggestBox_put_QueryIcon), nullptr, nullptr },
        { "placeholder_text", reinterpret_cast<getter>(AutoSuggestBox_get_PlaceholderText), reinterpret_cast<setter>(AutoSuggestBox_put_PlaceholderText), nullptr, nullptr },
        { "max_suggestion_list_height", reinterpret_cast<getter>(AutoSuggestBox_get_MaxSuggestionListHeight), reinterpret_cast<setter>(AutoSuggestBox_put_MaxSuggestionListHeight), nullptr, nullptr },
        { "light_dismiss_overlay_mode", reinterpret_cast<getter>(AutoSuggestBox_get_LightDismissOverlayMode), reinterpret_cast<setter>(AutoSuggestBox_put_LightDismissOverlayMode), nullptr, nullptr },
        { "is_suggestion_list_open", reinterpret_cast<getter>(AutoSuggestBox_get_IsSuggestionListOpen), reinterpret_cast<setter>(AutoSuggestBox_put_IsSuggestionListOpen), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(AutoSuggestBox_get_Header), reinterpret_cast<setter>(AutoSuggestBox_put_Header), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(AutoSuggestBox_get_Description), reinterpret_cast<setter>(AutoSuggestBox_put_Description), nullptr, nullptr },
        { "auto_maximize_suggestion_area", reinterpret_cast<getter>(AutoSuggestBox_get_AutoMaximizeSuggestionArea), reinterpret_cast<setter>(AutoSuggestBox_put_AutoMaximizeSuggestionArea), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AutoSuggestBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AutoSuggestBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AutoSuggestBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AutoSuggestBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AutoSuggestBox) },
        { },
    };

    static PyType_Spec type_spec_AutoSuggestBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AutoSuggestBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AutoSuggestBox
    };

    static PyGetSetDef getset_AutoSuggestBox_Static[] = {
        { "auto_maximize_suggestion_area_property", reinterpret_cast<getter>(AutoSuggestBox_get_AutoMaximizeSuggestionAreaProperty), nullptr, nullptr, nullptr },
        { "description_property", reinterpret_cast<getter>(AutoSuggestBox_get_DescriptionProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(AutoSuggestBox_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "is_suggestion_list_open_property", reinterpret_cast<getter>(AutoSuggestBox_get_IsSuggestionListOpenProperty), nullptr, nullptr, nullptr },
        { "light_dismiss_overlay_mode_property", reinterpret_cast<getter>(AutoSuggestBox_get_LightDismissOverlayModeProperty), nullptr, nullptr, nullptr },
        { "max_suggestion_list_height_property", reinterpret_cast<getter>(AutoSuggestBox_get_MaxSuggestionListHeightProperty), nullptr, nullptr, nullptr },
        { "placeholder_text_property", reinterpret_cast<getter>(AutoSuggestBox_get_PlaceholderTextProperty), nullptr, nullptr, nullptr },
        { "query_icon_property", reinterpret_cast<getter>(AutoSuggestBox_get_QueryIconProperty), nullptr, nullptr, nullptr },
        { "text_box_style_property", reinterpret_cast<getter>(AutoSuggestBox_get_TextBoxStyleProperty), nullptr, nullptr, nullptr },
        { "text_member_path_property", reinterpret_cast<getter>(AutoSuggestBox_get_TextMemberPathProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(AutoSuggestBox_get_TextProperty), nullptr, nullptr, nullptr },
        { "update_text_on_select_property", reinterpret_cast<getter>(AutoSuggestBox_get_UpdateTextOnSelectProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AutoSuggestBox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AutoSuggestBox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AutoSuggestBox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AutoSuggestBox_Static) },
        { }
    };

    static PyType_Spec type_spec_AutoSuggestBox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AutoSuggestBox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AutoSuggestBox_Static
    };

    // ----- AutoSuggestBoxQuerySubmittedEventArgs class --------------------

    static PyObject* _new_AutoSuggestBoxQuerySubmittedEventArgs(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::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs 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_AutoSuggestBoxQuerySubmittedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AutoSuggestBoxQuerySubmittedEventArgs_get_ChosenSuggestion(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs", L"ChosenSuggestion"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* AutoSuggestBoxQuerySubmittedEventArgs_get_QueryText(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs", L"QueryText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_AutoSuggestBoxQuerySubmittedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AutoSuggestBoxQuerySubmittedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AutoSuggestBoxQuerySubmittedEventArgs[] = {
        { "_assign_array_", _assign_array_AutoSuggestBoxQuerySubmittedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AutoSuggestBoxQuerySubmittedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AutoSuggestBoxQuerySubmittedEventArgs[] = {
        { "chosen_suggestion", reinterpret_cast<getter>(AutoSuggestBoxQuerySubmittedEventArgs_get_ChosenSuggestion), nullptr, nullptr, nullptr },
        { "query_text", reinterpret_cast<getter>(AutoSuggestBoxQuerySubmittedEventArgs_get_QueryText), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AutoSuggestBoxQuerySubmittedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AutoSuggestBoxQuerySubmittedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AutoSuggestBoxQuerySubmittedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AutoSuggestBoxQuerySubmittedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AutoSuggestBoxQuerySubmittedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_AutoSuggestBoxQuerySubmittedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AutoSuggestBoxQuerySubmittedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxQuerySubmittedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AutoSuggestBoxQuerySubmittedEventArgs
    };

    // ----- AutoSuggestBoxSuggestionChosenEventArgs class --------------------

    static PyObject* _new_AutoSuggestBoxSuggestionChosenEventArgs(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::Microsoft::UI::Xaml::Controls::AutoSuggestBoxSuggestionChosenEventArgs 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_AutoSuggestBoxSuggestionChosenEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxSuggestionChosenEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AutoSuggestBoxSuggestionChosenEventArgs_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxSuggestionChosenEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_AutoSuggestBoxSuggestionChosenEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxSuggestionChosenEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AutoSuggestBoxSuggestionChosenEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxSuggestionChosenEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AutoSuggestBoxSuggestionChosenEventArgs[] = {
        { "_assign_array_", _assign_array_AutoSuggestBoxSuggestionChosenEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AutoSuggestBoxSuggestionChosenEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AutoSuggestBoxSuggestionChosenEventArgs[] = {
        { "selected_item", reinterpret_cast<getter>(AutoSuggestBoxSuggestionChosenEventArgs_get_SelectedItem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AutoSuggestBoxSuggestionChosenEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AutoSuggestBoxSuggestionChosenEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AutoSuggestBoxSuggestionChosenEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AutoSuggestBoxSuggestionChosenEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AutoSuggestBoxSuggestionChosenEventArgs) },
        { },
    };

    static PyType_Spec type_spec_AutoSuggestBoxSuggestionChosenEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AutoSuggestBoxSuggestionChosenEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxSuggestionChosenEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AutoSuggestBoxSuggestionChosenEventArgs
    };

    // ----- AutoSuggestBoxTextChangedEventArgs class --------------------

    static PyObject* _new_AutoSuggestBoxTextChangedEventArgs(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::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs 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_AutoSuggestBoxTextChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* AutoSuggestBoxTextChangedEventArgs_CheckCurrent(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs", L"CheckCurrent", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* AutoSuggestBoxTextChangedEventArgs_get_Reason(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs", L"Reason"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int AutoSuggestBoxTextChangedEventArgs_put_Reason(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs", L"Reason"))
        {
            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::Microsoft::UI::Xaml::Controls::AutoSuggestionBoxTextChangeReason>(arg);

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

    static PyObject* AutoSuggestBoxTextChangedEventArgs_get_ReasonProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs", L"ReasonProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs::ReasonProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_AutoSuggestBoxTextChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_AutoSuggestBoxTextChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AutoSuggestBoxTextChangedEventArgs[] = {
        { "check_current", reinterpret_cast<PyCFunction>(AutoSuggestBoxTextChangedEventArgs_CheckCurrent), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_AutoSuggestBoxTextChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_AutoSuggestBoxTextChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AutoSuggestBoxTextChangedEventArgs[] = {
        { "reason", reinterpret_cast<getter>(AutoSuggestBoxTextChangedEventArgs_get_Reason), reinterpret_cast<setter>(AutoSuggestBoxTextChangedEventArgs_put_Reason), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AutoSuggestBoxTextChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_AutoSuggestBoxTextChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_AutoSuggestBoxTextChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_AutoSuggestBoxTextChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_AutoSuggestBoxTextChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_AutoSuggestBoxTextChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AutoSuggestBoxTextChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::AutoSuggestBoxTextChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AutoSuggestBoxTextChangedEventArgs
    };

    static PyGetSetDef getset_AutoSuggestBoxTextChangedEventArgs_Static[] = {
        { "reason_property", reinterpret_cast<getter>(AutoSuggestBoxTextChangedEventArgs_get_ReasonProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_AutoSuggestBoxTextChangedEventArgs_Static[] = {
        { }
    };

    static PyType_Slot type_slots_AutoSuggestBoxTextChangedEventArgs_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_AutoSuggestBoxTextChangedEventArgs_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_AutoSuggestBoxTextChangedEventArgs_Static) },
        { }
    };

    static PyType_Spec type_spec_AutoSuggestBoxTextChangedEventArgs_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.AutoSuggestBoxTextChangedEventArgs_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_AutoSuggestBoxTextChangedEventArgs_Static
    };

    // ----- BitmapIcon class --------------------

    static PyObject* _new_BitmapIcon(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::Microsoft::UI::Xaml::Controls::BitmapIcon 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_BitmapIcon(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIcon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BitmapIcon_get_UriSource(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIcon", L"UriSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int BitmapIcon_put_UriSource(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIcon", L"UriSource"))
        {
            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::Uri>(arg);

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

    static PyObject* BitmapIcon_get_ShowAsMonochrome(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIcon", L"ShowAsMonochrome"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int BitmapIcon_put_ShowAsMonochrome(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIcon", L"ShowAsMonochrome"))
        {
            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.ShowAsMonochrome(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* BitmapIcon_get_ShowAsMonochromeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIcon", L"ShowAsMonochromeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::BitmapIcon::ShowAsMonochromeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* BitmapIcon_get_UriSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIcon", L"UriSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::BitmapIcon::UriSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_BitmapIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::BitmapIcon>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_BitmapIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::BitmapIcon>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BitmapIcon[] = {
        { "_assign_array_", _assign_array_BitmapIcon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BitmapIcon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BitmapIcon[] = {
        { "uri_source", reinterpret_cast<getter>(BitmapIcon_get_UriSource), reinterpret_cast<setter>(BitmapIcon_put_UriSource), nullptr, nullptr },
        { "show_as_monochrome", reinterpret_cast<getter>(BitmapIcon_get_ShowAsMonochrome), reinterpret_cast<setter>(BitmapIcon_put_ShowAsMonochrome), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BitmapIcon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BitmapIcon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BitmapIcon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BitmapIcon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BitmapIcon) },
        { },
    };

    static PyType_Spec type_spec_BitmapIcon =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BitmapIcon",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIcon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BitmapIcon
    };

    static PyGetSetDef getset_BitmapIcon_Static[] = {
        { "show_as_monochrome_property", reinterpret_cast<getter>(BitmapIcon_get_ShowAsMonochromeProperty), nullptr, nullptr, nullptr },
        { "uri_source_property", reinterpret_cast<getter>(BitmapIcon_get_UriSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_BitmapIcon_Static[] = {
        { }
    };

    static PyType_Slot type_slots_BitmapIcon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_BitmapIcon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_BitmapIcon_Static) },
        { }
    };

    static PyType_Spec type_spec_BitmapIcon_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BitmapIcon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_BitmapIcon_Static
    };

    // ----- BitmapIconSource class --------------------

    static PyObject* _new_BitmapIconSource(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::Microsoft::UI::Xaml::Controls::BitmapIconSource 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_BitmapIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIconSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BitmapIconSource_get_UriSource(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIconSource", L"UriSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int BitmapIconSource_put_UriSource(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIconSource", L"UriSource"))
        {
            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::Uri>(arg);

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

    static PyObject* BitmapIconSource_get_ShowAsMonochrome(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIconSource", L"ShowAsMonochrome"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int BitmapIconSource_put_ShowAsMonochrome(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIconSource", L"ShowAsMonochrome"))
        {
            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.ShowAsMonochrome(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* BitmapIconSource_get_ShowAsMonochromeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIconSource", L"ShowAsMonochromeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::BitmapIconSource::ShowAsMonochromeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* BitmapIconSource_get_UriSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BitmapIconSource", L"UriSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::BitmapIconSource::UriSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_BitmapIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::BitmapIconSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_BitmapIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::BitmapIconSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BitmapIconSource[] = {
        { "_assign_array_", _assign_array_BitmapIconSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BitmapIconSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BitmapIconSource[] = {
        { "uri_source", reinterpret_cast<getter>(BitmapIconSource_get_UriSource), reinterpret_cast<setter>(BitmapIconSource_put_UriSource), nullptr, nullptr },
        { "show_as_monochrome", reinterpret_cast<getter>(BitmapIconSource_get_ShowAsMonochrome), reinterpret_cast<setter>(BitmapIconSource_put_ShowAsMonochrome), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BitmapIconSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BitmapIconSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BitmapIconSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BitmapIconSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BitmapIconSource) },
        { },
    };

    static PyType_Spec type_spec_BitmapIconSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BitmapIconSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::BitmapIconSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BitmapIconSource
    };

    static PyGetSetDef getset_BitmapIconSource_Static[] = {
        { "show_as_monochrome_property", reinterpret_cast<getter>(BitmapIconSource_get_ShowAsMonochromeProperty), nullptr, nullptr, nullptr },
        { "uri_source_property", reinterpret_cast<getter>(BitmapIconSource_get_UriSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_BitmapIconSource_Static[] = {
        { }
    };

    static PyType_Slot type_slots_BitmapIconSource_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_BitmapIconSource_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_BitmapIconSource_Static) },
        { }
    };

    static PyType_Spec type_spec_BitmapIconSource_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BitmapIconSource_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_BitmapIconSource_Static
    };

    // ----- Border class --------------------

    static PyObject* _new_Border(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::Microsoft::UI::Xaml::Controls::Border 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_Border(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Border_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* Border_get_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"CornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"CornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

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

    static PyObject* Border_get_ChildTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"ChildTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_ChildTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"ChildTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

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

    static PyObject* Border_get_Child(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"Child"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_Child(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"Child"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

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

    static PyObject* Border_get_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BorderThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BorderThickness"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* Border_get_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* Border_get_BackgroundTransition(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BackgroundTransition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_BackgroundTransition(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BackgroundTransition"))
        {
            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::Microsoft::UI::Xaml::BrushTransition>(arg);

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

    static PyObject* Border_get_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BackgroundSizing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BackgroundSizing"))
        {
            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::Microsoft::UI::Xaml::Controls::BackgroundSizing>(arg);

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

    static PyObject* Border_get_Background(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"Background"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Border_put_Background(py::wrapper::Microsoft::UI::Xaml::Controls::Border* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"Background"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* Border_get_BackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Border::BackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Border_get_BackgroundSizingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BackgroundSizingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Border::BackgroundSizingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Border_get_BorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Border::BorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Border_get_BorderThicknessProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"BorderThicknessProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Border::BorderThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Border_get_ChildTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"ChildTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Border::ChildTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Border_get_CornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"CornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Border::CornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Border_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Border", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Border::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Border(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Border>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Border(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Border>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Border[] = {
        { "_assign_array_", _assign_array_Border, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Border), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Border[] = {
        { "padding", reinterpret_cast<getter>(Border_get_Padding), reinterpret_cast<setter>(Border_put_Padding), nullptr, nullptr },
        { "corner_radius", reinterpret_cast<getter>(Border_get_CornerRadius), reinterpret_cast<setter>(Border_put_CornerRadius), nullptr, nullptr },
        { "child_transitions", reinterpret_cast<getter>(Border_get_ChildTransitions), reinterpret_cast<setter>(Border_put_ChildTransitions), nullptr, nullptr },
        { "child", reinterpret_cast<getter>(Border_get_Child), reinterpret_cast<setter>(Border_put_Child), nullptr, nullptr },
        { "border_thickness", reinterpret_cast<getter>(Border_get_BorderThickness), reinterpret_cast<setter>(Border_put_BorderThickness), nullptr, nullptr },
        { "border_brush", reinterpret_cast<getter>(Border_get_BorderBrush), reinterpret_cast<setter>(Border_put_BorderBrush), nullptr, nullptr },
        { "background_transition", reinterpret_cast<getter>(Border_get_BackgroundTransition), reinterpret_cast<setter>(Border_put_BackgroundTransition), nullptr, nullptr },
        { "background_sizing", reinterpret_cast<getter>(Border_get_BackgroundSizing), reinterpret_cast<setter>(Border_put_BackgroundSizing), nullptr, nullptr },
        { "background", reinterpret_cast<getter>(Border_get_Background), reinterpret_cast<setter>(Border_put_Background), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Border[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Border) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Border) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Border) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Border) },
        { },
    };

    static PyType_Spec type_spec_Border =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Border",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Border),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Border
    };

    static PyGetSetDef getset_Border_Static[] = {
        { "background_property", reinterpret_cast<getter>(Border_get_BackgroundProperty), nullptr, nullptr, nullptr },
        { "background_sizing_property", reinterpret_cast<getter>(Border_get_BackgroundSizingProperty), nullptr, nullptr, nullptr },
        { "border_brush_property", reinterpret_cast<getter>(Border_get_BorderBrushProperty), nullptr, nullptr, nullptr },
        { "border_thickness_property", reinterpret_cast<getter>(Border_get_BorderThicknessProperty), nullptr, nullptr, nullptr },
        { "child_transitions_property", reinterpret_cast<getter>(Border_get_ChildTransitionsProperty), nullptr, nullptr, nullptr },
        { "corner_radius_property", reinterpret_cast<getter>(Border_get_CornerRadiusProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(Border_get_PaddingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Border_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Border_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Border_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Border_Static) },
        { }
    };

    static PyType_Spec type_spec_Border_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Border_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Border_Static
    };

    // ----- BreadcrumbBar class --------------------

    static PyObject* _new_BreadcrumbBar(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::Microsoft::UI::Xaml::Controls::BreadcrumbBar 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_BreadcrumbBar(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BreadcrumbBar_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int BreadcrumbBar_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* BreadcrumbBar_get_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int BreadcrumbBar_put_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemTemplate"))
        {
            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.ItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* BreadcrumbBar_get_ItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBar::ItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* BreadcrumbBar_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBar::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* BreadcrumbBar_add_ItemClicked(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemClicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBar, winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs>>(arg);

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

    static PyObject* BreadcrumbBar_remove_ItemClicked(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBar", L"ItemClicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_BreadcrumbBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_BreadcrumbBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BreadcrumbBar[] = {
        { "add_item_clicked", reinterpret_cast<PyCFunction>(BreadcrumbBar_add_ItemClicked), METH_O, nullptr },
        { "remove_item_clicked", reinterpret_cast<PyCFunction>(BreadcrumbBar_remove_ItemClicked), METH_O, nullptr },
        { "_assign_array_", _assign_array_BreadcrumbBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BreadcrumbBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BreadcrumbBar[] = {
        { "items_source", reinterpret_cast<getter>(BreadcrumbBar_get_ItemsSource), reinterpret_cast<setter>(BreadcrumbBar_put_ItemsSource), nullptr, nullptr },
        { "item_template", reinterpret_cast<getter>(BreadcrumbBar_get_ItemTemplate), reinterpret_cast<setter>(BreadcrumbBar_put_ItemTemplate), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BreadcrumbBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BreadcrumbBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BreadcrumbBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BreadcrumbBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BreadcrumbBar) },
        { },
    };

    static PyType_Spec type_spec_BreadcrumbBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BreadcrumbBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BreadcrumbBar
    };

    static PyGetSetDef getset_BreadcrumbBar_Static[] = {
        { "item_template_property", reinterpret_cast<getter>(BreadcrumbBar_get_ItemTemplateProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(BreadcrumbBar_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_BreadcrumbBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_BreadcrumbBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_BreadcrumbBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_BreadcrumbBar_Static) },
        { }
    };

    static PyType_Spec type_spec_BreadcrumbBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BreadcrumbBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_BreadcrumbBar_Static
    };

    // ----- BreadcrumbBarItem class --------------------

    static PyObject* _new_BreadcrumbBarItem(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::Microsoft::UI::Xaml::Controls::BreadcrumbBarItem 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_BreadcrumbBarItem(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBarItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_BreadcrumbBarItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBarItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_BreadcrumbBarItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBarItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BreadcrumbBarItem[] = {
        { "_assign_array_", _assign_array_BreadcrumbBarItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BreadcrumbBarItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BreadcrumbBarItem[] = {
        { }
    };

    static PyType_Slot _type_slots_BreadcrumbBarItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BreadcrumbBarItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BreadcrumbBarItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BreadcrumbBarItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BreadcrumbBarItem) },
        { },
    };

    static PyType_Spec type_spec_BreadcrumbBarItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BreadcrumbBarItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBarItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BreadcrumbBarItem
    };

    // ----- BreadcrumbBarItemClickedEventArgs class --------------------

    static PyObject* _new_BreadcrumbBarItemClickedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BreadcrumbBarItemClickedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BreadcrumbBarItemClickedEventArgs_get_Index(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBarItemClickedEventArgs", L"Index"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* BreadcrumbBarItemClickedEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.BreadcrumbBarItemClickedEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_BreadcrumbBarItemClickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_BreadcrumbBarItemClickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BreadcrumbBarItemClickedEventArgs[] = {
        { "_assign_array_", _assign_array_BreadcrumbBarItemClickedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BreadcrumbBarItemClickedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BreadcrumbBarItemClickedEventArgs[] = {
        { "index", reinterpret_cast<getter>(BreadcrumbBarItemClickedEventArgs_get_Index), nullptr, nullptr, nullptr },
        { "item", reinterpret_cast<getter>(BreadcrumbBarItemClickedEventArgs_get_Item), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BreadcrumbBarItemClickedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BreadcrumbBarItemClickedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BreadcrumbBarItemClickedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BreadcrumbBarItemClickedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BreadcrumbBarItemClickedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BreadcrumbBarItemClickedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.BreadcrumbBarItemClickedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::BreadcrumbBarItemClickedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BreadcrumbBarItemClickedEventArgs
    };

    // ----- Button class --------------------

    static PyObject* _new_Button(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::Microsoft::UI::Xaml::Controls::Button 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_Button(py::wrapper::Microsoft::UI::Xaml::Controls::Button* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Button_get_Flyout(py::wrapper::Microsoft::UI::Xaml::Controls::Button* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Button", L"Flyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Button_put_Flyout(py::wrapper::Microsoft::UI::Xaml::Controls::Button* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Button", L"Flyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

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

    static PyObject* Button_get_FlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Button", L"FlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Button::FlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Button(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Button>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Button(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Button>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Button[] = {
        { "_assign_array_", _assign_array_Button, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Button), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Button[] = {
        { "flyout", reinterpret_cast<getter>(Button_get_Flyout), reinterpret_cast<setter>(Button_put_Flyout), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Button[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Button) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Button) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Button) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Button) },
        { },
    };

    static PyType_Spec type_spec_Button =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Button",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Button),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Button
    };

    static PyGetSetDef getset_Button_Static[] = {
        { "flyout_property", reinterpret_cast<getter>(Button_get_FlyoutProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Button_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Button_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Button_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Button_Static) },
        { }
    };

    static PyType_Spec type_spec_Button_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Button_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Button_Static
    };

    // ----- CalendarDatePicker class --------------------

    static PyObject* _new_CalendarDatePicker(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::Microsoft::UI::Xaml::Controls::CalendarDatePicker 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_CalendarDatePicker(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CalendarDatePicker_SetDisplayDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"SetDisplayDate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* CalendarDatePicker_SetYearDecadeDisplayDimensions(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"SetYearDecadeDisplayDimensions", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

    static PyObject* CalendarDatePicker_get_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"PlaceholderText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"PlaceholderText"))
        {
            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.PlaceholderText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_MinDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"MinDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_MinDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"MinDate"))
        {
            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::DateTime>(arg);

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

    static PyObject* CalendarDatePicker_get_MaxDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"MaxDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_MaxDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"MaxDate"))
        {
            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::DateTime>(arg);

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

    static PyObject* CalendarDatePicker_get_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"LightDismissOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"LightDismissOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::LightDismissOverlayMode>(arg);

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

    static PyObject* CalendarDatePicker_get_IsTodayHighlighted(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsTodayHighlighted"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_IsTodayHighlighted(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsTodayHighlighted"))
        {
            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.IsTodayHighlighted(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_IsOutOfScopeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsOutOfScopeEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_IsOutOfScopeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsOutOfScopeEnabled"))
        {
            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.IsOutOfScopeEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_IsGroupLabelVisible(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsGroupLabelVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_IsGroupLabelVisible(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsGroupLabelVisible"))
        {
            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.IsGroupLabelVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_IsCalendarOpen(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsCalendarOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_IsCalendarOpen(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsCalendarOpen"))
        {
            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.IsCalendarOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* CalendarDatePicker_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_FirstDayOfWeek(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"FirstDayOfWeek"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_FirstDayOfWeek(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"FirstDayOfWeek"))
        {
            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::Globalization::DayOfWeek>(arg);

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

    static PyObject* CalendarDatePicker_get_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DisplayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DisplayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::CalendarViewDisplayMode>(arg);

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

    static PyObject* CalendarDatePicker_get_Description(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Description"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_Description(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Description"))
        {
            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.Description(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_DayOfWeekFormat(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DayOfWeekFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_DayOfWeekFormat(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DayOfWeekFormat"))
        {
            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.DayOfWeekFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_DateFormat(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DateFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_DateFormat(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DateFormat"))
        {
            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.DateFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_Date(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Date"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_Date(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Date"))
        {
            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::IReference<winrt::Windows::Foundation::DateTime>>(arg);

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

    static PyObject* CalendarDatePicker_get_CalendarViewStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarViewStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_CalendarViewStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarViewStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* CalendarDatePicker_get_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarIdentifier"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarDatePicker_put_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarIdentifier"))
        {
            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.CalendarIdentifier(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarDatePicker_get_CalendarIdentifierProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarIdentifierProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::CalendarIdentifierProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_CalendarViewStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarViewStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::CalendarViewStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_DateFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DateFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::DateFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_DateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::DateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_DayOfWeekFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DayOfWeekFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::DayOfWeekFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_DescriptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DescriptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::DescriptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_DisplayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DisplayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::DisplayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_FirstDayOfWeekProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"FirstDayOfWeekProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::FirstDayOfWeekProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_IsCalendarOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsCalendarOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::IsCalendarOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_IsGroupLabelVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsGroupLabelVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::IsGroupLabelVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_IsOutOfScopeEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsOutOfScopeEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::IsOutOfScopeEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_IsTodayHighlightedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"IsTodayHighlightedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::IsTodayHighlightedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_LightDismissOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"LightDismissOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::LightDismissOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_MaxDateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"MaxDateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::MaxDateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_MinDateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"MinDateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::MinDateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_get_PlaceholderTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"PlaceholderTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker::PlaceholderTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarDatePicker_add_CalendarViewDayItemChanging(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarViewDayItemChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventHandler>(arg);

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

    static PyObject* CalendarDatePicker_remove_CalendarViewDayItemChanging(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"CalendarViewDayItemChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* CalendarDatePicker_add_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* CalendarDatePicker_remove_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* CalendarDatePicker_add_DateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker, winrt::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs>>(arg);

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

    static PyObject* CalendarDatePicker_remove_DateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"DateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* CalendarDatePicker_add_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* CalendarDatePicker_remove_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePicker", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_CalendarDatePicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CalendarDatePicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CalendarDatePicker>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CalendarDatePicker[] = {
        { "set_display_date", reinterpret_cast<PyCFunction>(CalendarDatePicker_SetDisplayDate), METH_VARARGS, nullptr },
        { "set_year_decade_display_dimensions", reinterpret_cast<PyCFunction>(CalendarDatePicker_SetYearDecadeDisplayDimensions), METH_VARARGS, nullptr },
        { "add_calendar_view_day_item_changing", reinterpret_cast<PyCFunction>(CalendarDatePicker_add_CalendarViewDayItemChanging), METH_O, nullptr },
        { "remove_calendar_view_day_item_changing", reinterpret_cast<PyCFunction>(CalendarDatePicker_remove_CalendarViewDayItemChanging), METH_O, nullptr },
        { "add_closed", reinterpret_cast<PyCFunction>(CalendarDatePicker_add_Closed), METH_O, nullptr },
        { "remove_closed", reinterpret_cast<PyCFunction>(CalendarDatePicker_remove_Closed), METH_O, nullptr },
        { "add_date_changed", reinterpret_cast<PyCFunction>(CalendarDatePicker_add_DateChanged), METH_O, nullptr },
        { "remove_date_changed", reinterpret_cast<PyCFunction>(CalendarDatePicker_remove_DateChanged), METH_O, nullptr },
        { "add_opened", reinterpret_cast<PyCFunction>(CalendarDatePicker_add_Opened), METH_O, nullptr },
        { "remove_opened", reinterpret_cast<PyCFunction>(CalendarDatePicker_remove_Opened), METH_O, nullptr },
        { "_assign_array_", _assign_array_CalendarDatePicker, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CalendarDatePicker), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CalendarDatePicker[] = {
        { "placeholder_text", reinterpret_cast<getter>(CalendarDatePicker_get_PlaceholderText), reinterpret_cast<setter>(CalendarDatePicker_put_PlaceholderText), nullptr, nullptr },
        { "min_date", reinterpret_cast<getter>(CalendarDatePicker_get_MinDate), reinterpret_cast<setter>(CalendarDatePicker_put_MinDate), nullptr, nullptr },
        { "max_date", reinterpret_cast<getter>(CalendarDatePicker_get_MaxDate), reinterpret_cast<setter>(CalendarDatePicker_put_MaxDate), nullptr, nullptr },
        { "light_dismiss_overlay_mode", reinterpret_cast<getter>(CalendarDatePicker_get_LightDismissOverlayMode), reinterpret_cast<setter>(CalendarDatePicker_put_LightDismissOverlayMode), nullptr, nullptr },
        { "is_today_highlighted", reinterpret_cast<getter>(CalendarDatePicker_get_IsTodayHighlighted), reinterpret_cast<setter>(CalendarDatePicker_put_IsTodayHighlighted), nullptr, nullptr },
        { "is_out_of_scope_enabled", reinterpret_cast<getter>(CalendarDatePicker_get_IsOutOfScopeEnabled), reinterpret_cast<setter>(CalendarDatePicker_put_IsOutOfScopeEnabled), nullptr, nullptr },
        { "is_group_label_visible", reinterpret_cast<getter>(CalendarDatePicker_get_IsGroupLabelVisible), reinterpret_cast<setter>(CalendarDatePicker_put_IsGroupLabelVisible), nullptr, nullptr },
        { "is_calendar_open", reinterpret_cast<getter>(CalendarDatePicker_get_IsCalendarOpen), reinterpret_cast<setter>(CalendarDatePicker_put_IsCalendarOpen), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(CalendarDatePicker_get_HeaderTemplate), reinterpret_cast<setter>(CalendarDatePicker_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(CalendarDatePicker_get_Header), reinterpret_cast<setter>(CalendarDatePicker_put_Header), nullptr, nullptr },
        { "first_day_of_week", reinterpret_cast<getter>(CalendarDatePicker_get_FirstDayOfWeek), reinterpret_cast<setter>(CalendarDatePicker_put_FirstDayOfWeek), nullptr, nullptr },
        { "display_mode", reinterpret_cast<getter>(CalendarDatePicker_get_DisplayMode), reinterpret_cast<setter>(CalendarDatePicker_put_DisplayMode), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(CalendarDatePicker_get_Description), reinterpret_cast<setter>(CalendarDatePicker_put_Description), nullptr, nullptr },
        { "day_of_week_format", reinterpret_cast<getter>(CalendarDatePicker_get_DayOfWeekFormat), reinterpret_cast<setter>(CalendarDatePicker_put_DayOfWeekFormat), nullptr, nullptr },
        { "date_format", reinterpret_cast<getter>(CalendarDatePicker_get_DateFormat), reinterpret_cast<setter>(CalendarDatePicker_put_DateFormat), nullptr, nullptr },
        { "date", reinterpret_cast<getter>(CalendarDatePicker_get_Date), reinterpret_cast<setter>(CalendarDatePicker_put_Date), nullptr, nullptr },
        { "calendar_view_style", reinterpret_cast<getter>(CalendarDatePicker_get_CalendarViewStyle), reinterpret_cast<setter>(CalendarDatePicker_put_CalendarViewStyle), nullptr, nullptr },
        { "calendar_identifier", reinterpret_cast<getter>(CalendarDatePicker_get_CalendarIdentifier), reinterpret_cast<setter>(CalendarDatePicker_put_CalendarIdentifier), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CalendarDatePicker[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CalendarDatePicker) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CalendarDatePicker) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CalendarDatePicker) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CalendarDatePicker) },
        { },
    };

    static PyType_Spec type_spec_CalendarDatePicker =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarDatePicker",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePicker),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CalendarDatePicker
    };

    static PyGetSetDef getset_CalendarDatePicker_Static[] = {
        { "calendar_identifier_property", reinterpret_cast<getter>(CalendarDatePicker_get_CalendarIdentifierProperty), nullptr, nullptr, nullptr },
        { "calendar_view_style_property", reinterpret_cast<getter>(CalendarDatePicker_get_CalendarViewStyleProperty), nullptr, nullptr, nullptr },
        { "date_format_property", reinterpret_cast<getter>(CalendarDatePicker_get_DateFormatProperty), nullptr, nullptr, nullptr },
        { "date_property", reinterpret_cast<getter>(CalendarDatePicker_get_DateProperty), nullptr, nullptr, nullptr },
        { "day_of_week_format_property", reinterpret_cast<getter>(CalendarDatePicker_get_DayOfWeekFormatProperty), nullptr, nullptr, nullptr },
        { "description_property", reinterpret_cast<getter>(CalendarDatePicker_get_DescriptionProperty), nullptr, nullptr, nullptr },
        { "display_mode_property", reinterpret_cast<getter>(CalendarDatePicker_get_DisplayModeProperty), nullptr, nullptr, nullptr },
        { "first_day_of_week_property", reinterpret_cast<getter>(CalendarDatePicker_get_FirstDayOfWeekProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(CalendarDatePicker_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(CalendarDatePicker_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_calendar_open_property", reinterpret_cast<getter>(CalendarDatePicker_get_IsCalendarOpenProperty), nullptr, nullptr, nullptr },
        { "is_group_label_visible_property", reinterpret_cast<getter>(CalendarDatePicker_get_IsGroupLabelVisibleProperty), nullptr, nullptr, nullptr },
        { "is_out_of_scope_enabled_property", reinterpret_cast<getter>(CalendarDatePicker_get_IsOutOfScopeEnabledProperty), nullptr, nullptr, nullptr },
        { "is_today_highlighted_property", reinterpret_cast<getter>(CalendarDatePicker_get_IsTodayHighlightedProperty), nullptr, nullptr, nullptr },
        { "light_dismiss_overlay_mode_property", reinterpret_cast<getter>(CalendarDatePicker_get_LightDismissOverlayModeProperty), nullptr, nullptr, nullptr },
        { "max_date_property", reinterpret_cast<getter>(CalendarDatePicker_get_MaxDateProperty), nullptr, nullptr, nullptr },
        { "min_date_property", reinterpret_cast<getter>(CalendarDatePicker_get_MinDateProperty), nullptr, nullptr, nullptr },
        { "placeholder_text_property", reinterpret_cast<getter>(CalendarDatePicker_get_PlaceholderTextProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_CalendarDatePicker_Static[] = {
        { }
    };

    static PyType_Slot type_slots_CalendarDatePicker_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_CalendarDatePicker_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_CalendarDatePicker_Static) },
        { }
    };

    static PyType_Spec type_spec_CalendarDatePicker_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarDatePicker_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_CalendarDatePicker_Static
    };

    // ----- CalendarDatePickerDateChangedEventArgs class --------------------

    static PyObject* _new_CalendarDatePickerDateChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_CalendarDatePickerDateChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CalendarDatePickerDateChangedEventArgs_get_NewDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs", L"NewDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CalendarDatePickerDateChangedEventArgs_get_OldDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs", L"OldDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_CalendarDatePickerDateChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CalendarDatePickerDateChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CalendarDatePickerDateChangedEventArgs[] = {
        { "_assign_array_", _assign_array_CalendarDatePickerDateChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CalendarDatePickerDateChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CalendarDatePickerDateChangedEventArgs[] = {
        { "new_date", reinterpret_cast<getter>(CalendarDatePickerDateChangedEventArgs_get_NewDate), nullptr, nullptr, nullptr },
        { "old_date", reinterpret_cast<getter>(CalendarDatePickerDateChangedEventArgs_get_OldDate), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CalendarDatePickerDateChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CalendarDatePickerDateChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CalendarDatePickerDateChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CalendarDatePickerDateChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CalendarDatePickerDateChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_CalendarDatePickerDateChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarDatePickerDateChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarDatePickerDateChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CalendarDatePickerDateChangedEventArgs
    };

    // ----- CalendarView class --------------------

    static PyObject* _new_CalendarView(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::Microsoft::UI::Xaml::Controls::CalendarView 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_CalendarView(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CalendarView_SetDisplayDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SetDisplayDate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* CalendarView_SetYearDecadeDisplayDimensions(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SetYearDecadeDisplayDimensions", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

    static PyObject* CalendarView_get_DayItemMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemMargin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DayItemMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemMargin"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* CalendarView_get_DayItemFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DayItemFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* CalendarView_get_DayItemFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DayItemFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* CalendarView_get_DayItemFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DayItemFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontSize"))
        {
            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<double>(arg);

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

    static PyObject* CalendarView_get_DayItemFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DayItemFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* CalendarView_get_CalendarViewDayItemStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarViewDayItemStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarViewDayItemStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarViewDayItemStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* CalendarView_get_CalendarItemPressedBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemPressedBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemPressedBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemPressedBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_CalendarItemHoverBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemHoverBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemHoverBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemHoverBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_TodayBlackoutBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBlackoutBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayBlackoutBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBlackoutBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_CalendarItemDisabledBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemDisabledBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemDisabledBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemDisabledBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_CalendarItemCornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemCornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemCornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemCornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

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

    static PyObject* CalendarView_get_CalendarItemBorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBorderThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemBorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBorderThickness"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* CalendarView_get_CalendarItemBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_CalendarItemBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarIdentifier"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarIdentifier"))
        {
            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.CalendarIdentifier(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarView_get_BlackoutStrikethroughBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutStrikethroughBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_BlackoutStrikethroughBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutStrikethroughBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_BlackoutForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_BlackoutForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_IsGroupLabelVisible(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsGroupLabelVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_IsGroupLabelVisible(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsGroupLabelVisible"))
        {
            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.IsGroupLabelVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarView_get_BlackoutBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_BlackoutBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_DayOfWeekFormat(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayOfWeekFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DayOfWeekFormat(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayOfWeekFormat"))
        {
            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.DayOfWeekFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarView_get_HoverBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HoverBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_HoverBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HoverBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_HorizontalFirstOfMonthLabelAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HorizontalFirstOfMonthLabelAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_HorizontalFirstOfMonthLabelAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HorizontalFirstOfMonthLabelAlignment"))
        {
            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::Microsoft::UI::Xaml::HorizontalAlignment>(arg);

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

    static PyObject* CalendarView_get_HorizontalDayItemAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HorizontalDayItemAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_HorizontalDayItemAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HorizontalDayItemAlignment"))
        {
            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::Microsoft::UI::Xaml::HorizontalAlignment>(arg);

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

    static PyObject* CalendarView_get_FocusBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FocusBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FocusBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FocusBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelMargin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfYearDecadeLabelMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelMargin"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfYearDecadeLabelFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfYearDecadeLabelFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* CalendarView_get_NumberOfWeeksInView(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"NumberOfWeeksInView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_NumberOfWeeksInView(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"NumberOfWeeksInView"))
        {
            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<int32_t>(arg);

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

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfYearDecadeLabelFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* CalendarView_get_FirstOfMonthLabelMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelMargin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfMonthLabelMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelMargin"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* CalendarView_get_FirstOfMonthLabelFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfMonthLabelFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* CalendarView_get_FirstOfMonthLabelFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfMonthLabelFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* CalendarView_get_FirstOfMonthLabelFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfMonthLabelFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontSize"))
        {
            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<double>(arg);

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

    static PyObject* CalendarView_get_FirstOfMonthLabelFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfMonthLabelFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* CalendarView_get_FirstDayOfWeek(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstDayOfWeek"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstDayOfWeek(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstDayOfWeek"))
        {
            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::Globalization::DayOfWeek>(arg);

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

    static PyObject* CalendarView_get_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DisplayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DisplayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::CalendarViewDisplayMode>(arg);

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

    static PyObject* CalendarView_get_DisabledForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DisabledForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_DisabledForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DisabledForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_IsOutOfScopeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsOutOfScopeEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_IsOutOfScopeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsOutOfScopeEnabled"))
        {
            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.IsOutOfScopeEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarView_get_SelectedDisabledBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDisabledBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedDisabledBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDisabledBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_SelectedBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_PressedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"PressedForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_PressedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"PressedForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_PressedBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"PressedBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_PressedBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"PressedBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_OutOfScopePressedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopePressedForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_OutOfScopePressedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopePressedForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_OutOfScopeHoverForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeHoverForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_OutOfScopeHoverForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeHoverForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_OutOfScopeForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_OutOfScopeForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_OutOfScopeBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_OutOfScopeBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_FirstOfYearDecadeLabelFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontSize"))
        {
            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<double>(arg);

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

    static PyObject* CalendarView_get_MonthYearItemMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemMargin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_MonthYearItemMargin(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemMargin"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* CalendarView_get_MonthYearItemFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_MonthYearItemFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* CalendarView_get_MonthYearItemFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_MonthYearItemFontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* CalendarView_get_MonthYearItemFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_MonthYearItemFontSize(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontSize"))
        {
            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<double>(arg);

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

    static PyObject* CalendarView_get_MonthYearItemFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_MonthYearItemFontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* CalendarView_get_MinDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MinDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_MinDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MinDate"))
        {
            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::DateTime>(arg);

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

    static PyObject* CalendarView_get_MaxDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MaxDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_MaxDate(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MaxDate"))
        {
            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::DateTime>(arg);

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

    static PyObject* CalendarView_get_SelectedDisabledForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDisabledForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedDisabledForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDisabledForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_VerticalFirstOfMonthLabelAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"VerticalFirstOfMonthLabelAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_VerticalFirstOfMonthLabelAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"VerticalFirstOfMonthLabelAlignment"))
        {
            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::Microsoft::UI::Xaml::VerticalAlignment>(arg);

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

    static PyObject* CalendarView_get_IsTodayHighlighted(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsTodayHighlighted"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_IsTodayHighlighted(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsTodayHighlighted"))
        {
            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.IsTodayHighlighted(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarView_get_VerticalDayItemAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"VerticalDayItemAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_VerticalDayItemAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"VerticalDayItemAlignment"))
        {
            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::Microsoft::UI::Xaml::VerticalAlignment>(arg);

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

    static PyObject* CalendarView_get_TodaySelectedInnerBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodaySelectedInnerBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodaySelectedInnerBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodaySelectedInnerBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_TodayPressedBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayPressedBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayPressedBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayPressedBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_TodayHoverBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayHoverBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayHoverBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayHoverBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_TodayForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_TodayFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayFontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayFontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayFontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* CalendarView_get_TodayDisabledBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayDisabledBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayDisabledBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayDisabledBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_TodayBlackoutForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBlackoutForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayBlackoutForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBlackoutForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_CalendarItemForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_CalendarItemForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_TodayBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_TodayBackground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectionMode"))
        {
            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::Microsoft::UI::Xaml::Controls::CalendarViewSelectionMode>(arg);

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

    static PyObject* CalendarView_get_SelectedPressedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedPressedForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedPressedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedPressedForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_SelectedPressedBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedPressedBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedPressedBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedPressedBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_SelectedHoverForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedHoverForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedHoverForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedHoverForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_SelectedHoverBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedHoverBorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedHoverBorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedHoverBorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_SelectedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarView_put_SelectedForeground(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* CalendarView_get_SelectedDates(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDates"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CalendarView_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CalendarView_get_BlackoutBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::BlackoutBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_BlackoutForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::BlackoutForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_BlackoutStrikethroughBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"BlackoutStrikethroughBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::BlackoutStrikethroughBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarIdentifierProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarIdentifierProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarIdentifierProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemBorderThicknessProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemBorderThicknessProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemBorderThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemCornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemCornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemCornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemDisabledBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemDisabledBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemDisabledBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemHoverBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemHoverBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemHoverBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarItemPressedBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarItemPressedBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarItemPressedBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_CalendarViewDayItemStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarViewDayItemStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::CalendarViewDayItemStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DayItemFontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DayItemFontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DayItemFontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DayItemFontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DayItemFontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DayItemFontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DayItemFontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemFontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DayItemFontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DayItemMarginProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayItemMarginProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DayItemMarginProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DayOfWeekFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DayOfWeekFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DayOfWeekFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DisabledForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DisabledForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DisabledForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_DisplayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"DisplayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::DisplayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstDayOfWeekProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstDayOfWeekProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstDayOfWeekProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfMonthLabelFontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfMonthLabelFontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfMonthLabelFontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfMonthLabelFontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfMonthLabelFontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfMonthLabelFontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfMonthLabelFontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelFontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfMonthLabelFontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfMonthLabelMarginProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfMonthLabelMarginProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfMonthLabelMarginProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfYearDecadeLabelFontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfYearDecadeLabelFontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfYearDecadeLabelFontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelFontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelFontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfYearDecadeLabelFontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FirstOfYearDecadeLabelMarginProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FirstOfYearDecadeLabelMarginProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FirstOfYearDecadeLabelMarginProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_FocusBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"FocusBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::FocusBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_HorizontalDayItemAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HorizontalDayItemAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::HorizontalDayItemAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_HorizontalFirstOfMonthLabelAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HorizontalFirstOfMonthLabelAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::HorizontalFirstOfMonthLabelAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_HoverBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"HoverBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::HoverBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_IsGroupLabelVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsGroupLabelVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::IsGroupLabelVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_IsOutOfScopeEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsOutOfScopeEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::IsOutOfScopeEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_IsTodayHighlightedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"IsTodayHighlightedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::IsTodayHighlightedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_MaxDateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MaxDateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::MaxDateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_MinDateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MinDateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::MinDateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_MonthYearItemFontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::MonthYearItemFontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_MonthYearItemFontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::MonthYearItemFontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_MonthYearItemFontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::MonthYearItemFontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_MonthYearItemFontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemFontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::MonthYearItemFontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_MonthYearItemMarginProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"MonthYearItemMarginProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::MonthYearItemMarginProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_NumberOfWeeksInViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"NumberOfWeeksInViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::NumberOfWeeksInViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_OutOfScopeBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::OutOfScopeBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_OutOfScopeForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::OutOfScopeForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_OutOfScopeHoverForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopeHoverForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::OutOfScopeHoverForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_OutOfScopePressedForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"OutOfScopePressedForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::OutOfScopePressedForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_PressedBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"PressedBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::PressedBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_PressedForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"PressedForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::PressedForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedDatesProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDatesProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedDatesProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedDisabledBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDisabledBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedDisabledBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedDisabledForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDisabledForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedDisabledForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedHoverBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedHoverBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedHoverBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedHoverForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedHoverForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedHoverForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedPressedBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedPressedBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedPressedBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectedPressedForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedPressedForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectedPressedForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_SelectionModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectionModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::SelectionModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayBlackoutBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBlackoutBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayBlackoutBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayBlackoutForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayBlackoutForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayBlackoutForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayDisabledBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayDisabledBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayDisabledBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayFontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayFontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayFontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayHoverBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayHoverBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayHoverBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodayPressedBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodayPressedBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodayPressedBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_TodaySelectedInnerBorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"TodaySelectedInnerBorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::TodaySelectedInnerBorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_VerticalDayItemAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"VerticalDayItemAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::VerticalDayItemAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_get_VerticalFirstOfMonthLabelAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"VerticalFirstOfMonthLabelAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarView::VerticalFirstOfMonthLabelAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarView_add_CalendarViewDayItemChanging(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarViewDayItemChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::CalendarView, winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs>>(arg);

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

    static PyObject* CalendarView_remove_CalendarViewDayItemChanging(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"CalendarViewDayItemChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* CalendarView_add_SelectedDatesChanged(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDatesChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::CalendarView, winrt::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs>>(arg);

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

    static PyObject* CalendarView_remove_SelectedDatesChanged(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CalendarView", L"SelectedDatesChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_CalendarView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CalendarView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CalendarView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CalendarView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CalendarView[] = {
        { "set_display_date", reinterpret_cast<PyCFunction>(CalendarView_SetDisplayDate), METH_VARARGS, nullptr },
        { "set_year_decade_display_dimensions", reinterpret_cast<PyCFunction>(CalendarView_SetYearDecadeDisplayDimensions), METH_VARARGS, nullptr },
        { "add_calendar_view_day_item_changing", reinterpret_cast<PyCFunction>(CalendarView_add_CalendarViewDayItemChanging), METH_O, nullptr },
        { "remove_calendar_view_day_item_changing", reinterpret_cast<PyCFunction>(CalendarView_remove_CalendarViewDayItemChanging), METH_O, nullptr },
        { "add_selected_dates_changed", reinterpret_cast<PyCFunction>(CalendarView_add_SelectedDatesChanged), METH_O, nullptr },
        { "remove_selected_dates_changed", reinterpret_cast<PyCFunction>(CalendarView_remove_SelectedDatesChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_CalendarView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CalendarView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CalendarView[] = {
        { "day_item_margin", reinterpret_cast<getter>(CalendarView_get_DayItemMargin), reinterpret_cast<setter>(CalendarView_put_DayItemMargin), nullptr, nullptr },
        { "day_item_font_weight", reinterpret_cast<getter>(CalendarView_get_DayItemFontWeight), reinterpret_cast<setter>(CalendarView_put_DayItemFontWeight), nullptr, nullptr },
        { "day_item_font_style", reinterpret_cast<getter>(CalendarView_get_DayItemFontStyle), reinterpret_cast<setter>(CalendarView_put_DayItemFontStyle), nullptr, nullptr },
        { "day_item_font_size", reinterpret_cast<getter>(CalendarView_get_DayItemFontSize), reinterpret_cast<setter>(CalendarView_put_DayItemFontSize), nullptr, nullptr },
        { "day_item_font_family", reinterpret_cast<getter>(CalendarView_get_DayItemFontFamily), reinterpret_cast<setter>(CalendarView_put_DayItemFontFamily), nullptr, nullptr },
        { "calendar_view_day_item_style", reinterpret_cast<getter>(CalendarView_get_CalendarViewDayItemStyle), reinterpret_cast<setter>(CalendarView_put_CalendarViewDayItemStyle), nullptr, nullptr },
        { "calendar_item_pressed_background", reinterpret_cast<getter>(CalendarView_get_CalendarItemPressedBackground), reinterpret_cast<setter>(CalendarView_put_CalendarItemPressedBackground), nullptr, nullptr },
        { "calendar_item_hover_background", reinterpret_cast<getter>(CalendarView_get_CalendarItemHoverBackground), reinterpret_cast<setter>(CalendarView_put_CalendarItemHoverBackground), nullptr, nullptr },
        { "today_blackout_background", reinterpret_cast<getter>(CalendarView_get_TodayBlackoutBackground), reinterpret_cast<setter>(CalendarView_put_TodayBlackoutBackground), nullptr, nullptr },
        { "calendar_item_disabled_background", reinterpret_cast<getter>(CalendarView_get_CalendarItemDisabledBackground), reinterpret_cast<setter>(CalendarView_put_CalendarItemDisabledBackground), nullptr, nullptr },
        { "calendar_item_corner_radius", reinterpret_cast<getter>(CalendarView_get_CalendarItemCornerRadius), reinterpret_cast<setter>(CalendarView_put_CalendarItemCornerRadius), nullptr, nullptr },
        { "calendar_item_border_thickness", reinterpret_cast<getter>(CalendarView_get_CalendarItemBorderThickness), reinterpret_cast<setter>(CalendarView_put_CalendarItemBorderThickness), nullptr, nullptr },
        { "calendar_item_border_brush", reinterpret_cast<getter>(CalendarView_get_CalendarItemBorderBrush), reinterpret_cast<setter>(CalendarView_put_CalendarItemBorderBrush), nullptr, nullptr },
        { "calendar_item_background", reinterpret_cast<getter>(CalendarView_get_CalendarItemBackground), reinterpret_cast<setter>(CalendarView_put_CalendarItemBackground), nullptr, nullptr },
        { "calendar_identifier", reinterpret_cast<getter>(CalendarView_get_CalendarIdentifier), reinterpret_cast<setter>(CalendarView_put_CalendarIdentifier), nullptr, nullptr },
        { "blackout_strikethrough_brush", reinterpret_cast<getter>(CalendarView_get_BlackoutStrikethroughBrush), reinterpret_cast<setter>(CalendarView_put_BlackoutStrikethroughBrush), nullptr, nullptr },
        { "blackout_foreground", reinterpret_cast<getter>(CalendarView_get_BlackoutForeground), reinterpret_cast<setter>(CalendarView_put_BlackoutForeground), nullptr, nullptr },
        { "is_group_label_visible", reinterpret_cast<getter>(CalendarView_get_IsGroupLabelVisible), reinterpret_cast<setter>(CalendarView_put_IsGroupLabelVisible), nullptr, nullptr },
        { "blackout_background", reinterpret_cast<getter>(CalendarView_get_BlackoutBackground), reinterpret_cast<setter>(CalendarView_put_BlackoutBackground), nullptr, nullptr },
        { "day_of_week_format", reinterpret_cast<getter>(CalendarView_get_DayOfWeekFormat), reinterpret_cast<setter>(CalendarView_put_DayOfWeekFormat), nullptr, nullptr },
        { "hover_border_brush", reinterpret_cast<getter>(CalendarView_get_HoverBorderBrush), reinterpret_cast<setter>(CalendarView_put_HoverBorderBrush), nullptr, nullptr },
        { "horizontal_first_of_month_label_alignment", reinterpret_cast<getter>(CalendarView_get_HorizontalFirstOfMonthLabelAlignment), reinterpret_cast<setter>(CalendarView_put_HorizontalFirstOfMonthLabelAlignment), nullptr, nullptr },
        { "horizontal_day_item_alignment", reinterpret_cast<getter>(CalendarView_get_HorizontalDayItemAlignment), reinterpret_cast<setter>(CalendarView_put_HorizontalDayItemAlignment), nullptr, nullptr },
        { "focus_border_brush", reinterpret_cast<getter>(CalendarView_get_FocusBorderBrush), reinterpret_cast<setter>(CalendarView_put_FocusBorderBrush), nullptr, nullptr },
        { "first_of_year_decade_label_margin", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelMargin), reinterpret_cast<setter>(CalendarView_put_FirstOfYearDecadeLabelMargin), nullptr, nullptr },
        { "first_of_year_decade_label_font_weight", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontWeight), reinterpret_cast<setter>(CalendarView_put_FirstOfYearDecadeLabelFontWeight), nullptr, nullptr },
        { "first_of_year_decade_label_font_style", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontStyle), reinterpret_cast<setter>(CalendarView_put_FirstOfYearDecadeLabelFontStyle), nullptr, nullptr },
        { "number_of_weeks_in_view", reinterpret_cast<getter>(CalendarView_get_NumberOfWeeksInView), reinterpret_cast<setter>(CalendarView_put_NumberOfWeeksInView), nullptr, nullptr },
        { "first_of_year_decade_label_font_family", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontFamily), reinterpret_cast<setter>(CalendarView_put_FirstOfYearDecadeLabelFontFamily), nullptr, nullptr },
        { "first_of_month_label_margin", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelMargin), reinterpret_cast<setter>(CalendarView_put_FirstOfMonthLabelMargin), nullptr, nullptr },
        { "first_of_month_label_font_weight", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontWeight), reinterpret_cast<setter>(CalendarView_put_FirstOfMonthLabelFontWeight), nullptr, nullptr },
        { "first_of_month_label_font_style", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontStyle), reinterpret_cast<setter>(CalendarView_put_FirstOfMonthLabelFontStyle), nullptr, nullptr },
        { "first_of_month_label_font_size", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontSize), reinterpret_cast<setter>(CalendarView_put_FirstOfMonthLabelFontSize), nullptr, nullptr },
        { "first_of_month_label_font_family", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontFamily), reinterpret_cast<setter>(CalendarView_put_FirstOfMonthLabelFontFamily), nullptr, nullptr },
        { "first_day_of_week", reinterpret_cast<getter>(CalendarView_get_FirstDayOfWeek), reinterpret_cast<setter>(CalendarView_put_FirstDayOfWeek), nullptr, nullptr },
        { "display_mode", reinterpret_cast<getter>(CalendarView_get_DisplayMode), reinterpret_cast<setter>(CalendarView_put_DisplayMode), nullptr, nullptr },
        { "disabled_foreground", reinterpret_cast<getter>(CalendarView_get_DisabledForeground), reinterpret_cast<setter>(CalendarView_put_DisabledForeground), nullptr, nullptr },
        { "is_out_of_scope_enabled", reinterpret_cast<getter>(CalendarView_get_IsOutOfScopeEnabled), reinterpret_cast<setter>(CalendarView_put_IsOutOfScopeEnabled), nullptr, nullptr },
        { "selected_disabled_border_brush", reinterpret_cast<getter>(CalendarView_get_SelectedDisabledBorderBrush), reinterpret_cast<setter>(CalendarView_put_SelectedDisabledBorderBrush), nullptr, nullptr },
        { "selected_border_brush", reinterpret_cast<getter>(CalendarView_get_SelectedBorderBrush), reinterpret_cast<setter>(CalendarView_put_SelectedBorderBrush), nullptr, nullptr },
        { "pressed_foreground", reinterpret_cast<getter>(CalendarView_get_PressedForeground), reinterpret_cast<setter>(CalendarView_put_PressedForeground), nullptr, nullptr },
        { "pressed_border_brush", reinterpret_cast<getter>(CalendarView_get_PressedBorderBrush), reinterpret_cast<setter>(CalendarView_put_PressedBorderBrush), nullptr, nullptr },
        { "out_of_scope_pressed_foreground", reinterpret_cast<getter>(CalendarView_get_OutOfScopePressedForeground), reinterpret_cast<setter>(CalendarView_put_OutOfScopePressedForeground), nullptr, nullptr },
        { "out_of_scope_hover_foreground", reinterpret_cast<getter>(CalendarView_get_OutOfScopeHoverForeground), reinterpret_cast<setter>(CalendarView_put_OutOfScopeHoverForeground), nullptr, nullptr },
        { "out_of_scope_foreground", reinterpret_cast<getter>(CalendarView_get_OutOfScopeForeground), reinterpret_cast<setter>(CalendarView_put_OutOfScopeForeground), nullptr, nullptr },
        { "out_of_scope_background", reinterpret_cast<getter>(CalendarView_get_OutOfScopeBackground), reinterpret_cast<setter>(CalendarView_put_OutOfScopeBackground), nullptr, nullptr },
        { "first_of_year_decade_label_font_size", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontSize), reinterpret_cast<setter>(CalendarView_put_FirstOfYearDecadeLabelFontSize), nullptr, nullptr },
        { "month_year_item_margin", reinterpret_cast<getter>(CalendarView_get_MonthYearItemMargin), reinterpret_cast<setter>(CalendarView_put_MonthYearItemMargin), nullptr, nullptr },
        { "month_year_item_font_weight", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontWeight), reinterpret_cast<setter>(CalendarView_put_MonthYearItemFontWeight), nullptr, nullptr },
        { "month_year_item_font_style", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontStyle), reinterpret_cast<setter>(CalendarView_put_MonthYearItemFontStyle), nullptr, nullptr },
        { "month_year_item_font_size", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontSize), reinterpret_cast<setter>(CalendarView_put_MonthYearItemFontSize), nullptr, nullptr },
        { "month_year_item_font_family", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontFamily), reinterpret_cast<setter>(CalendarView_put_MonthYearItemFontFamily), nullptr, nullptr },
        { "min_date", reinterpret_cast<getter>(CalendarView_get_MinDate), reinterpret_cast<setter>(CalendarView_put_MinDate), nullptr, nullptr },
        { "max_date", reinterpret_cast<getter>(CalendarView_get_MaxDate), reinterpret_cast<setter>(CalendarView_put_MaxDate), nullptr, nullptr },
        { "selected_disabled_foreground", reinterpret_cast<getter>(CalendarView_get_SelectedDisabledForeground), reinterpret_cast<setter>(CalendarView_put_SelectedDisabledForeground), nullptr, nullptr },
        { "vertical_first_of_month_label_alignment", reinterpret_cast<getter>(CalendarView_get_VerticalFirstOfMonthLabelAlignment), reinterpret_cast<setter>(CalendarView_put_VerticalFirstOfMonthLabelAlignment), nullptr, nullptr },
        { "is_today_highlighted", reinterpret_cast<getter>(CalendarView_get_IsTodayHighlighted), reinterpret_cast<setter>(CalendarView_put_IsTodayHighlighted), nullptr, nullptr },
        { "vertical_day_item_alignment", reinterpret_cast<getter>(CalendarView_get_VerticalDayItemAlignment), reinterpret_cast<setter>(CalendarView_put_VerticalDayItemAlignment), nullptr, nullptr },
        { "today_selected_inner_border_brush", reinterpret_cast<getter>(CalendarView_get_TodaySelectedInnerBorderBrush), reinterpret_cast<setter>(CalendarView_put_TodaySelectedInnerBorderBrush), nullptr, nullptr },
        { "today_pressed_background", reinterpret_cast<getter>(CalendarView_get_TodayPressedBackground), reinterpret_cast<setter>(CalendarView_put_TodayPressedBackground), nullptr, nullptr },
        { "today_hover_background", reinterpret_cast<getter>(CalendarView_get_TodayHoverBackground), reinterpret_cast<setter>(CalendarView_put_TodayHoverBackground), nullptr, nullptr },
        { "today_foreground", reinterpret_cast<getter>(CalendarView_get_TodayForeground), reinterpret_cast<setter>(CalendarView_put_TodayForeground), nullptr, nullptr },
        { "today_font_weight", reinterpret_cast<getter>(CalendarView_get_TodayFontWeight), reinterpret_cast<setter>(CalendarView_put_TodayFontWeight), nullptr, nullptr },
        { "today_disabled_background", reinterpret_cast<getter>(CalendarView_get_TodayDisabledBackground), reinterpret_cast<setter>(CalendarView_put_TodayDisabledBackground), nullptr, nullptr },
        { "today_blackout_foreground", reinterpret_cast<getter>(CalendarView_get_TodayBlackoutForeground), reinterpret_cast<setter>(CalendarView_put_TodayBlackoutForeground), nullptr, nullptr },
        { "calendar_item_foreground", reinterpret_cast<getter>(CalendarView_get_CalendarItemForeground), reinterpret_cast<setter>(CalendarView_put_CalendarItemForeground), nullptr, nullptr },
        { "today_background", reinterpret_cast<getter>(CalendarView_get_TodayBackground), reinterpret_cast<setter>(CalendarView_put_TodayBackground), nullptr, nullptr },
        { "selection_mode", reinterpret_cast<getter>(CalendarView_get_SelectionMode), reinterpret_cast<setter>(CalendarView_put_SelectionMode), nullptr, nullptr },
        { "selected_pressed_foreground", reinterpret_cast<getter>(CalendarView_get_SelectedPressedForeground), reinterpret_cast<setter>(CalendarView_put_SelectedPressedForeground), nullptr, nullptr },
        { "selected_pressed_border_brush", reinterpret_cast<getter>(CalendarView_get_SelectedPressedBorderBrush), reinterpret_cast<setter>(CalendarView_put_SelectedPressedBorderBrush), nullptr, nullptr },
        { "selected_hover_foreground", reinterpret_cast<getter>(CalendarView_get_SelectedHoverForeground), reinterpret_cast<setter>(CalendarView_put_SelectedHoverForeground), nullptr, nullptr },
        { "selected_hover_border_brush", reinterpret_cast<getter>(CalendarView_get_SelectedHoverBorderBrush), reinterpret_cast<setter>(CalendarView_put_SelectedHoverBorderBrush), nullptr, nullptr },
        { "selected_foreground", reinterpret_cast<getter>(CalendarView_get_SelectedForeground), reinterpret_cast<setter>(CalendarView_put_SelectedForeground), nullptr, nullptr },
        { "selected_dates", reinterpret_cast<getter>(CalendarView_get_SelectedDates), nullptr, nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(CalendarView_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CalendarView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CalendarView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CalendarView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CalendarView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CalendarView) },
        { },
    };

    static PyType_Spec type_spec_CalendarView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CalendarView
    };

    static PyGetSetDef getset_CalendarView_Static[] = {
        { "blackout_background_property", reinterpret_cast<getter>(CalendarView_get_BlackoutBackgroundProperty), nullptr, nullptr, nullptr },
        { "blackout_foreground_property", reinterpret_cast<getter>(CalendarView_get_BlackoutForegroundProperty), nullptr, nullptr, nullptr },
        { "blackout_strikethrough_brush_property", reinterpret_cast<getter>(CalendarView_get_BlackoutStrikethroughBrushProperty), nullptr, nullptr, nullptr },
        { "calendar_identifier_property", reinterpret_cast<getter>(CalendarView_get_CalendarIdentifierProperty), nullptr, nullptr, nullptr },
        { "calendar_item_background_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemBackgroundProperty), nullptr, nullptr, nullptr },
        { "calendar_item_border_brush_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemBorderBrushProperty), nullptr, nullptr, nullptr },
        { "calendar_item_border_thickness_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemBorderThicknessProperty), nullptr, nullptr, nullptr },
        { "calendar_item_corner_radius_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemCornerRadiusProperty), nullptr, nullptr, nullptr },
        { "calendar_item_disabled_background_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemDisabledBackgroundProperty), nullptr, nullptr, nullptr },
        { "calendar_item_foreground_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemForegroundProperty), nullptr, nullptr, nullptr },
        { "calendar_item_hover_background_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemHoverBackgroundProperty), nullptr, nullptr, nullptr },
        { "calendar_item_pressed_background_property", reinterpret_cast<getter>(CalendarView_get_CalendarItemPressedBackgroundProperty), nullptr, nullptr, nullptr },
        { "calendar_view_day_item_style_property", reinterpret_cast<getter>(CalendarView_get_CalendarViewDayItemStyleProperty), nullptr, nullptr, nullptr },
        { "day_item_font_family_property", reinterpret_cast<getter>(CalendarView_get_DayItemFontFamilyProperty), nullptr, nullptr, nullptr },
        { "day_item_font_size_property", reinterpret_cast<getter>(CalendarView_get_DayItemFontSizeProperty), nullptr, nullptr, nullptr },
        { "day_item_font_style_property", reinterpret_cast<getter>(CalendarView_get_DayItemFontStyleProperty), nullptr, nullptr, nullptr },
        { "day_item_font_weight_property", reinterpret_cast<getter>(CalendarView_get_DayItemFontWeightProperty), nullptr, nullptr, nullptr },
        { "day_item_margin_property", reinterpret_cast<getter>(CalendarView_get_DayItemMarginProperty), nullptr, nullptr, nullptr },
        { "day_of_week_format_property", reinterpret_cast<getter>(CalendarView_get_DayOfWeekFormatProperty), nullptr, nullptr, nullptr },
        { "disabled_foreground_property", reinterpret_cast<getter>(CalendarView_get_DisabledForegroundProperty), nullptr, nullptr, nullptr },
        { "display_mode_property", reinterpret_cast<getter>(CalendarView_get_DisplayModeProperty), nullptr, nullptr, nullptr },
        { "first_day_of_week_property", reinterpret_cast<getter>(CalendarView_get_FirstDayOfWeekProperty), nullptr, nullptr, nullptr },
        { "first_of_month_label_font_family_property", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontFamilyProperty), nullptr, nullptr, nullptr },
        { "first_of_month_label_font_size_property", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontSizeProperty), nullptr, nullptr, nullptr },
        { "first_of_month_label_font_style_property", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontStyleProperty), nullptr, nullptr, nullptr },
        { "first_of_month_label_font_weight_property", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelFontWeightProperty), nullptr, nullptr, nullptr },
        { "first_of_month_label_margin_property", reinterpret_cast<getter>(CalendarView_get_FirstOfMonthLabelMarginProperty), nullptr, nullptr, nullptr },
        { "first_of_year_decade_label_font_family_property", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontFamilyProperty), nullptr, nullptr, nullptr },
        { "first_of_year_decade_label_font_size_property", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontSizeProperty), nullptr, nullptr, nullptr },
        { "first_of_year_decade_label_font_style_property", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontStyleProperty), nullptr, nullptr, nullptr },
        { "first_of_year_decade_label_font_weight_property", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelFontWeightProperty), nullptr, nullptr, nullptr },
        { "first_of_year_decade_label_margin_property", reinterpret_cast<getter>(CalendarView_get_FirstOfYearDecadeLabelMarginProperty), nullptr, nullptr, nullptr },
        { "focus_border_brush_property", reinterpret_cast<getter>(CalendarView_get_FocusBorderBrushProperty), nullptr, nullptr, nullptr },
        { "horizontal_day_item_alignment_property", reinterpret_cast<getter>(CalendarView_get_HorizontalDayItemAlignmentProperty), nullptr, nullptr, nullptr },
        { "horizontal_first_of_month_label_alignment_property", reinterpret_cast<getter>(CalendarView_get_HorizontalFirstOfMonthLabelAlignmentProperty), nullptr, nullptr, nullptr },
        { "hover_border_brush_property", reinterpret_cast<getter>(CalendarView_get_HoverBorderBrushProperty), nullptr, nullptr, nullptr },
        { "is_group_label_visible_property", reinterpret_cast<getter>(CalendarView_get_IsGroupLabelVisibleProperty), nullptr, nullptr, nullptr },
        { "is_out_of_scope_enabled_property", reinterpret_cast<getter>(CalendarView_get_IsOutOfScopeEnabledProperty), nullptr, nullptr, nullptr },
        { "is_today_highlighted_property", reinterpret_cast<getter>(CalendarView_get_IsTodayHighlightedProperty), nullptr, nullptr, nullptr },
        { "max_date_property", reinterpret_cast<getter>(CalendarView_get_MaxDateProperty), nullptr, nullptr, nullptr },
        { "min_date_property", reinterpret_cast<getter>(CalendarView_get_MinDateProperty), nullptr, nullptr, nullptr },
        { "month_year_item_font_family_property", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontFamilyProperty), nullptr, nullptr, nullptr },
        { "month_year_item_font_size_property", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontSizeProperty), nullptr, nullptr, nullptr },
        { "month_year_item_font_style_property", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontStyleProperty), nullptr, nullptr, nullptr },
        { "month_year_item_font_weight_property", reinterpret_cast<getter>(CalendarView_get_MonthYearItemFontWeightProperty), nullptr, nullptr, nullptr },
        { "month_year_item_margin_property", reinterpret_cast<getter>(CalendarView_get_MonthYearItemMarginProperty), nullptr, nullptr, nullptr },
        { "number_of_weeks_in_view_property", reinterpret_cast<getter>(CalendarView_get_NumberOfWeeksInViewProperty), nullptr, nullptr, nullptr },
        { "out_of_scope_background_property", reinterpret_cast<getter>(CalendarView_get_OutOfScopeBackgroundProperty), nullptr, nullptr, nullptr },
        { "out_of_scope_foreground_property", reinterpret_cast<getter>(CalendarView_get_OutOfScopeForegroundProperty), nullptr, nullptr, nullptr },
        { "out_of_scope_hover_foreground_property", reinterpret_cast<getter>(CalendarView_get_OutOfScopeHoverForegroundProperty), nullptr, nullptr, nullptr },
        { "out_of_scope_pressed_foreground_property", reinterpret_cast<getter>(CalendarView_get_OutOfScopePressedForegroundProperty), nullptr, nullptr, nullptr },
        { "pressed_border_brush_property", reinterpret_cast<getter>(CalendarView_get_PressedBorderBrushProperty), nullptr, nullptr, nullptr },
        { "pressed_foreground_property", reinterpret_cast<getter>(CalendarView_get_PressedForegroundProperty), nullptr, nullptr, nullptr },
        { "selected_border_brush_property", reinterpret_cast<getter>(CalendarView_get_SelectedBorderBrushProperty), nullptr, nullptr, nullptr },
        { "selected_dates_property", reinterpret_cast<getter>(CalendarView_get_SelectedDatesProperty), nullptr, nullptr, nullptr },
        { "selected_disabled_border_brush_property", reinterpret_cast<getter>(CalendarView_get_SelectedDisabledBorderBrushProperty), nullptr, nullptr, nullptr },
        { "selected_disabled_foreground_property", reinterpret_cast<getter>(CalendarView_get_SelectedDisabledForegroundProperty), nullptr, nullptr, nullptr },
        { "selected_foreground_property", reinterpret_cast<getter>(CalendarView_get_SelectedForegroundProperty), nullptr, nullptr, nullptr },
        { "selected_hover_border_brush_property", reinterpret_cast<getter>(CalendarView_get_SelectedHoverBorderBrushProperty), nullptr, nullptr, nullptr },
        { "selected_hover_foreground_property", reinterpret_cast<getter>(CalendarView_get_SelectedHoverForegroundProperty), nullptr, nullptr, nullptr },
        { "selected_pressed_border_brush_property", reinterpret_cast<getter>(CalendarView_get_SelectedPressedBorderBrushProperty), nullptr, nullptr, nullptr },
        { "selected_pressed_foreground_property", reinterpret_cast<getter>(CalendarView_get_SelectedPressedForegroundProperty), nullptr, nullptr, nullptr },
        { "selection_mode_property", reinterpret_cast<getter>(CalendarView_get_SelectionModeProperty), nullptr, nullptr, nullptr },
        { "template_settings_property", reinterpret_cast<getter>(CalendarView_get_TemplateSettingsProperty), nullptr, nullptr, nullptr },
        { "today_background_property", reinterpret_cast<getter>(CalendarView_get_TodayBackgroundProperty), nullptr, nullptr, nullptr },
        { "today_blackout_background_property", reinterpret_cast<getter>(CalendarView_get_TodayBlackoutBackgroundProperty), nullptr, nullptr, nullptr },
        { "today_blackout_foreground_property", reinterpret_cast<getter>(CalendarView_get_TodayBlackoutForegroundProperty), nullptr, nullptr, nullptr },
        { "today_disabled_background_property", reinterpret_cast<getter>(CalendarView_get_TodayDisabledBackgroundProperty), nullptr, nullptr, nullptr },
        { "today_font_weight_property", reinterpret_cast<getter>(CalendarView_get_TodayFontWeightProperty), nullptr, nullptr, nullptr },
        { "today_foreground_property", reinterpret_cast<getter>(CalendarView_get_TodayForegroundProperty), nullptr, nullptr, nullptr },
        { "today_hover_background_property", reinterpret_cast<getter>(CalendarView_get_TodayHoverBackgroundProperty), nullptr, nullptr, nullptr },
        { "today_pressed_background_property", reinterpret_cast<getter>(CalendarView_get_TodayPressedBackgroundProperty), nullptr, nullptr, nullptr },
        { "today_selected_inner_border_brush_property", reinterpret_cast<getter>(CalendarView_get_TodaySelectedInnerBorderBrushProperty), nullptr, nullptr, nullptr },
        { "vertical_day_item_alignment_property", reinterpret_cast<getter>(CalendarView_get_VerticalDayItemAlignmentProperty), nullptr, nullptr, nullptr },
        { "vertical_first_of_month_label_alignment_property", reinterpret_cast<getter>(CalendarView_get_VerticalFirstOfMonthLabelAlignmentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_CalendarView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_CalendarView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_CalendarView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_CalendarView_Static) },
        { }
    };

    static PyType_Spec type_spec_CalendarView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_CalendarView_Static
    };

    // ----- CalendarViewDayItem class --------------------

    static PyObject* _new_CalendarViewDayItem(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::Microsoft::UI::Xaml::Controls::CalendarViewDayItem 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_CalendarViewDayItem(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CalendarViewDayItem_SetDensityColors(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItem* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItem", L"SetDensityColors", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::UI::Color>>(args, 0);

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

    static PyObject* CalendarViewDayItem_get_IsBlackout(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItem", L"IsBlackout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CalendarViewDayItem_put_IsBlackout(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItem", L"IsBlackout"))
        {
            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.IsBlackout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CalendarViewDayItem_get_Date(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItem", L"Date"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CalendarViewDayItem_get_DateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItem", L"DateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItem::DateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CalendarViewDayItem_get_IsBlackoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItem", L"IsBlackoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItem::IsBlackoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_CalendarViewDayItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CalendarViewDayItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CalendarViewDayItem[] = {
        { "set_density_colors", reinterpret_cast<PyCFunction>(CalendarViewDayItem_SetDensityColors), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_CalendarViewDayItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CalendarViewDayItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CalendarViewDayItem[] = {
        { "is_blackout", reinterpret_cast<getter>(CalendarViewDayItem_get_IsBlackout), reinterpret_cast<setter>(CalendarViewDayItem_put_IsBlackout), nullptr, nullptr },
        { "date", reinterpret_cast<getter>(CalendarViewDayItem_get_Date), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CalendarViewDayItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CalendarViewDayItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CalendarViewDayItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CalendarViewDayItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CalendarViewDayItem) },
        { },
    };

    static PyType_Spec type_spec_CalendarViewDayItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarViewDayItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CalendarViewDayItem
    };

    static PyGetSetDef getset_CalendarViewDayItem_Static[] = {
        { "date_property", reinterpret_cast<getter>(CalendarViewDayItem_get_DateProperty), nullptr, nullptr, nullptr },
        { "is_blackout_property", reinterpret_cast<getter>(CalendarViewDayItem_get_IsBlackoutProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_CalendarViewDayItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_CalendarViewDayItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_CalendarViewDayItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_CalendarViewDayItem_Static) },
        { }
    };

    static PyType_Spec type_spec_CalendarViewDayItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarViewDayItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_CalendarViewDayItem_Static
    };

    // ----- CalendarViewDayItemChangingEventArgs class --------------------

    static PyObject* _new_CalendarViewDayItemChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_CalendarViewDayItemChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CalendarViewDayItemChangingEventArgs_RegisterUpdateCallback(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs", L"RegisterUpdateCallback", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::CalendarView, winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs>>(args, 0);

                self->obj.RegisterUpdateCallback(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs", L"RegisterUpdateCallback", 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::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::CalendarView, winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs>>(args, 1);

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

    static PyObject* CalendarViewDayItemChangingEventArgs_get_InRecycleQueue(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs", L"InRecycleQueue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CalendarViewDayItemChangingEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CalendarViewDayItemChangingEventArgs_get_Phase(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs", L"Phase"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_CalendarViewDayItemChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CalendarViewDayItemChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CalendarViewDayItemChangingEventArgs[] = {
        { "register_update_callback", reinterpret_cast<PyCFunction>(CalendarViewDayItemChangingEventArgs_RegisterUpdateCallback), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_CalendarViewDayItemChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CalendarViewDayItemChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CalendarViewDayItemChangingEventArgs[] = {
        { "in_recycle_queue", reinterpret_cast<getter>(CalendarViewDayItemChangingEventArgs_get_InRecycleQueue), nullptr, nullptr, nullptr },
        { "item", reinterpret_cast<getter>(CalendarViewDayItemChangingEventArgs_get_Item), nullptr, nullptr, nullptr },
        { "phase", reinterpret_cast<getter>(CalendarViewDayItemChangingEventArgs_get_Phase), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CalendarViewDayItemChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CalendarViewDayItemChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CalendarViewDayItemChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CalendarViewDayItemChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CalendarViewDayItemChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_CalendarViewDayItemChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarViewDayItemChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewDayItemChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CalendarViewDayItemChangingEventArgs
    };

    // ----- CalendarViewSelectedDatesChangedEventArgs class --------------------

    static PyObject* _new_CalendarViewSelectedDatesChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_CalendarViewSelectedDatesChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CalendarViewSelectedDatesChangedEventArgs_get_AddedDates(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs", L"AddedDates"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CalendarViewSelectedDatesChangedEventArgs_get_RemovedDates(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs", L"RemovedDates"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_CalendarViewSelectedDatesChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CalendarViewSelectedDatesChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CalendarViewSelectedDatesChangedEventArgs[] = {
        { "_assign_array_", _assign_array_CalendarViewSelectedDatesChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CalendarViewSelectedDatesChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CalendarViewSelectedDatesChangedEventArgs[] = {
        { "added_dates", reinterpret_cast<getter>(CalendarViewSelectedDatesChangedEventArgs_get_AddedDates), nullptr, nullptr, nullptr },
        { "removed_dates", reinterpret_cast<getter>(CalendarViewSelectedDatesChangedEventArgs_get_RemovedDates), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CalendarViewSelectedDatesChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CalendarViewSelectedDatesChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CalendarViewSelectedDatesChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CalendarViewSelectedDatesChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CalendarViewSelectedDatesChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_CalendarViewSelectedDatesChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CalendarViewSelectedDatesChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CalendarViewSelectedDatesChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CalendarViewSelectedDatesChangedEventArgs
    };

    // ----- CandidateWindowBoundsChangedEventArgs class --------------------

    static PyObject* _new_CandidateWindowBoundsChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_CandidateWindowBoundsChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CandidateWindowBoundsChangedEventArgs_get_Bounds(py::wrapper::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs", L"Bounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_CandidateWindowBoundsChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CandidateWindowBoundsChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CandidateWindowBoundsChangedEventArgs[] = {
        { "_assign_array_", _assign_array_CandidateWindowBoundsChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CandidateWindowBoundsChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CandidateWindowBoundsChangedEventArgs[] = {
        { "bounds", reinterpret_cast<getter>(CandidateWindowBoundsChangedEventArgs_get_Bounds), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CandidateWindowBoundsChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CandidateWindowBoundsChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CandidateWindowBoundsChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CandidateWindowBoundsChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CandidateWindowBoundsChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_CandidateWindowBoundsChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CandidateWindowBoundsChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CandidateWindowBoundsChangedEventArgs
    };

    // ----- Canvas class --------------------

    static PyObject* _new_Canvas(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::Microsoft::UI::Xaml::Controls::Canvas 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_Canvas(py::wrapper::Microsoft::UI::Xaml::Controls::Canvas* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Canvas_GetLeft(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"GetLeft", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Canvas::GetLeft(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Canvas_GetTop(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"GetTop", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Canvas::GetTop(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Canvas_GetZIndex(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"GetZIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Canvas::GetZIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Canvas_SetLeft(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"SetLeft", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Canvas::SetLeft(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Canvas_SetTop(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"SetTop", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Canvas::SetTop(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Canvas_SetZIndex(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"SetZIndex", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Canvas::SetZIndex(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Canvas_get_LeftProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"LeftProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Canvas::LeftProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Canvas_get_TopProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"TopProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Canvas::TopProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Canvas_get_ZIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Canvas", L"ZIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Canvas::ZIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Canvas(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Canvas>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Canvas(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Canvas>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Canvas[] = {
        { "_assign_array_", _assign_array_Canvas, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Canvas), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Canvas[] = {
        { }
    };

    static PyType_Slot _type_slots_Canvas[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Canvas) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Canvas) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Canvas) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Canvas) },
        { },
    };

    static PyType_Spec type_spec_Canvas =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Canvas",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Canvas),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Canvas
    };

    static PyGetSetDef getset_Canvas_Static[] = {
        { "left_property", reinterpret_cast<getter>(Canvas_get_LeftProperty), nullptr, nullptr, nullptr },
        { "top_property", reinterpret_cast<getter>(Canvas_get_TopProperty), nullptr, nullptr, nullptr },
        { "z_index_property", reinterpret_cast<getter>(Canvas_get_ZIndexProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Canvas_Static[] = {
        { "get_left", reinterpret_cast<PyCFunction>(Canvas_GetLeft), METH_VARARGS, nullptr },
        { "get_top", reinterpret_cast<PyCFunction>(Canvas_GetTop), METH_VARARGS, nullptr },
        { "get_z_index", reinterpret_cast<PyCFunction>(Canvas_GetZIndex), METH_VARARGS, nullptr },
        { "set_left", reinterpret_cast<PyCFunction>(Canvas_SetLeft), METH_VARARGS, nullptr },
        { "set_top", reinterpret_cast<PyCFunction>(Canvas_SetTop), METH_VARARGS, nullptr },
        { "set_z_index", reinterpret_cast<PyCFunction>(Canvas_SetZIndex), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_Canvas_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Canvas_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Canvas_Static) },
        { }
    };

    static PyType_Spec type_spec_Canvas_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Canvas_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Canvas_Static
    };

    // ----- CheckBox class --------------------

    static PyObject* _new_CheckBox(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::Microsoft::UI::Xaml::Controls::CheckBox 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_CheckBox(py::wrapper::Microsoft::UI::Xaml::Controls::CheckBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_CheckBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CheckBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CheckBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CheckBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CheckBox[] = {
        { "_assign_array_", _assign_array_CheckBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CheckBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CheckBox[] = {
        { }
    };

    static PyType_Slot _type_slots_CheckBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CheckBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CheckBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CheckBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CheckBox) },
        { },
    };

    static PyType_Spec type_spec_CheckBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CheckBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CheckBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CheckBox
    };

    // ----- ChoosingGroupHeaderContainerEventArgs class --------------------

    static PyObject* _new_ChoosingGroupHeaderContainerEventArgs(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::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs 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_ChoosingGroupHeaderContainerEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ChoosingGroupHeaderContainerEventArgs_get_GroupHeaderContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs", L"GroupHeaderContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ChoosingGroupHeaderContainerEventArgs_put_GroupHeaderContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs", L"GroupHeaderContainer"))
        {
            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::Microsoft::UI::Xaml::Controls::ListViewBaseHeaderItem>(arg);

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

    static PyObject* ChoosingGroupHeaderContainerEventArgs_get_Group(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs", L"Group"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ChoosingGroupHeaderContainerEventArgs_get_GroupIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs", L"GroupIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ChoosingGroupHeaderContainerEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ChoosingGroupHeaderContainerEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ChoosingGroupHeaderContainerEventArgs[] = {
        { "_assign_array_", _assign_array_ChoosingGroupHeaderContainerEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ChoosingGroupHeaderContainerEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ChoosingGroupHeaderContainerEventArgs[] = {
        { "group_header_container", reinterpret_cast<getter>(ChoosingGroupHeaderContainerEventArgs_get_GroupHeaderContainer), reinterpret_cast<setter>(ChoosingGroupHeaderContainerEventArgs_put_GroupHeaderContainer), nullptr, nullptr },
        { "group", reinterpret_cast<getter>(ChoosingGroupHeaderContainerEventArgs_get_Group), nullptr, nullptr, nullptr },
        { "group_index", reinterpret_cast<getter>(ChoosingGroupHeaderContainerEventArgs_get_GroupIndex), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ChoosingGroupHeaderContainerEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ChoosingGroupHeaderContainerEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ChoosingGroupHeaderContainerEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ChoosingGroupHeaderContainerEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ChoosingGroupHeaderContainerEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ChoosingGroupHeaderContainerEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ChoosingGroupHeaderContainerEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ChoosingGroupHeaderContainerEventArgs
    };

    // ----- ChoosingItemContainerEventArgs class --------------------

    static PyObject* _new_ChoosingItemContainerEventArgs(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::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs 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_ChoosingItemContainerEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ChoosingItemContainerEventArgs_get_ItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs", L"ItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ChoosingItemContainerEventArgs_put_ItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs", L"ItemContainer"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::SelectorItem>(arg);

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

    static PyObject* ChoosingItemContainerEventArgs_get_IsContainerPrepared(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs", L"IsContainerPrepared"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ChoosingItemContainerEventArgs_put_IsContainerPrepared(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs", L"IsContainerPrepared"))
        {
            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.IsContainerPrepared(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ChoosingItemContainerEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ChoosingItemContainerEventArgs_get_ItemIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs", L"ItemIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ChoosingItemContainerEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ChoosingItemContainerEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ChoosingItemContainerEventArgs[] = {
        { "_assign_array_", _assign_array_ChoosingItemContainerEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ChoosingItemContainerEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ChoosingItemContainerEventArgs[] = {
        { "item_container", reinterpret_cast<getter>(ChoosingItemContainerEventArgs_get_ItemContainer), reinterpret_cast<setter>(ChoosingItemContainerEventArgs_put_ItemContainer), nullptr, nullptr },
        { "is_container_prepared", reinterpret_cast<getter>(ChoosingItemContainerEventArgs_get_IsContainerPrepared), reinterpret_cast<setter>(ChoosingItemContainerEventArgs_put_IsContainerPrepared), nullptr, nullptr },
        { "item", reinterpret_cast<getter>(ChoosingItemContainerEventArgs_get_Item), nullptr, nullptr, nullptr },
        { "item_index", reinterpret_cast<getter>(ChoosingItemContainerEventArgs_get_ItemIndex), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ChoosingItemContainerEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ChoosingItemContainerEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ChoosingItemContainerEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ChoosingItemContainerEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ChoosingItemContainerEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ChoosingItemContainerEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ChoosingItemContainerEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ChoosingItemContainerEventArgs
    };

    // ----- CleanUpVirtualizedItemEventArgs class --------------------

    static PyObject* _new_CleanUpVirtualizedItemEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_CleanUpVirtualizedItemEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CleanUpVirtualizedItemEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CleanUpVirtualizedItemEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CleanUpVirtualizedItemEventArgs_get_UIElement(py::wrapper::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs", L"UIElement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CleanUpVirtualizedItemEventArgs_get_Value(py::wrapper::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs", 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 PyObject* _assign_array_CleanUpVirtualizedItemEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CleanUpVirtualizedItemEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CleanUpVirtualizedItemEventArgs[] = {
        { "_assign_array_", _assign_array_CleanUpVirtualizedItemEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CleanUpVirtualizedItemEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CleanUpVirtualizedItemEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(CleanUpVirtualizedItemEventArgs_get_Cancel), reinterpret_cast<setter>(CleanUpVirtualizedItemEventArgs_put_Cancel), nullptr, nullptr },
        { "u_i_element", reinterpret_cast<getter>(CleanUpVirtualizedItemEventArgs_get_UIElement), nullptr, nullptr, nullptr },
        { "value", reinterpret_cast<getter>(CleanUpVirtualizedItemEventArgs_get_Value), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CleanUpVirtualizedItemEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CleanUpVirtualizedItemEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CleanUpVirtualizedItemEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CleanUpVirtualizedItemEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CleanUpVirtualizedItemEventArgs) },
        { },
    };

    static PyType_Spec type_spec_CleanUpVirtualizedItemEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CleanUpVirtualizedItemEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CleanUpVirtualizedItemEventArgs
    };

    // ----- ColorChangedEventArgs class --------------------

    static PyObject* _new_ColorChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ColorChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ColorChangedEventArgs_get_NewColor(py::wrapper::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorChangedEventArgs", L"NewColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ColorChangedEventArgs_get_OldColor(py::wrapper::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorChangedEventArgs", L"OldColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ColorChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ColorChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ColorChangedEventArgs[] = {
        { "_assign_array_", _assign_array_ColorChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ColorChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ColorChangedEventArgs[] = {
        { "new_color", reinterpret_cast<getter>(ColorChangedEventArgs_get_NewColor), nullptr, nullptr, nullptr },
        { "old_color", reinterpret_cast<getter>(ColorChangedEventArgs_get_OldColor), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ColorChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ColorChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ColorChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ColorChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ColorChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ColorChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ColorChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ColorChangedEventArgs
    };

    // ----- ColorPicker class --------------------

    static PyObject* _new_ColorPicker(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::Microsoft::UI::Xaml::Controls::ColorPicker 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_ColorPicker(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ColorPicker_get_PreviousColor(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"PreviousColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_PreviousColor(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"PreviousColor"))
        {
            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::IReference<winrt::Windows::UI::Color>>(arg);

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

    static PyObject* ColorPicker_get_MinValue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_MinValue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinValue"))
        {
            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<int32_t>(arg);

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

    static PyObject* ColorPicker_get_MinSaturation(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinSaturation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_MinSaturation(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinSaturation"))
        {
            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<int32_t>(arg);

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

    static PyObject* ColorPicker_get_MinHue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinHue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_MinHue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinHue"))
        {
            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<int32_t>(arg);

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

    static PyObject* ColorPicker_get_MaxValue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_MaxValue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxValue"))
        {
            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<int32_t>(arg);

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

    static PyObject* ColorPicker_get_MaxSaturation(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxSaturation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_MaxSaturation(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxSaturation"))
        {
            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<int32_t>(arg);

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

    static PyObject* ColorPicker_get_MaxHue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxHue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_MaxHue(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxHue"))
        {
            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<int32_t>(arg);

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

    static PyObject* ColorPicker_get_IsMoreButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsMoreButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsMoreButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsMoreButtonVisible"))
        {
            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.IsMoreButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsHexInputVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsHexInputVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsHexInputVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsHexInputVisible"))
        {
            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.IsHexInputVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsColorSpectrumVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorSpectrumVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsColorSpectrumVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorSpectrumVisible"))
        {
            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.IsColorSpectrumVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsColorSliderVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorSliderVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsColorSliderVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorSliderVisible"))
        {
            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.IsColorSliderVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsColorPreviewVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorPreviewVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsColorPreviewVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorPreviewVisible"))
        {
            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.IsColorPreviewVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsColorChannelTextInputVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorChannelTextInputVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsColorChannelTextInputVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorChannelTextInputVisible"))
        {
            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.IsColorChannelTextInputVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsAlphaTextInputVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaTextInputVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsAlphaTextInputVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaTextInputVisible"))
        {
            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.IsAlphaTextInputVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsAlphaSliderVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaSliderVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsAlphaSliderVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaSliderVisible"))
        {
            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.IsAlphaSliderVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_IsAlphaEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_IsAlphaEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaEnabled"))
        {
            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.IsAlphaEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ColorPicker_get_ColorSpectrumShape(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorSpectrumShape"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_ColorSpectrumShape(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorSpectrumShape"))
        {
            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::Microsoft::UI::Xaml::Controls::ColorSpectrumShape>(arg);

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

    static PyObject* ColorPicker_get_ColorSpectrumComponents(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorSpectrumComponents"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_ColorSpectrumComponents(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorSpectrumComponents"))
        {
            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::Microsoft::UI::Xaml::Controls::ColorSpectrumComponents>(arg);

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

    static PyObject* ColorPicker_get_Color(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"Color"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_Color(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"Color"))
        {
            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::UI::Color>(arg);

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

    static PyObject* ColorPicker_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColorPicker_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

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

    static PyObject* ColorPicker_get_ColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::ColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_ColorSpectrumComponentsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorSpectrumComponentsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::ColorSpectrumComponentsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_ColorSpectrumShapeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorSpectrumShapeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::ColorSpectrumShapeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsAlphaEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsAlphaEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsAlphaSliderVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaSliderVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsAlphaSliderVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsAlphaTextInputVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsAlphaTextInputVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsAlphaTextInputVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsColorChannelTextInputVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorChannelTextInputVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsColorChannelTextInputVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsColorPreviewVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorPreviewVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsColorPreviewVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsColorSliderVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorSliderVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsColorSliderVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsColorSpectrumVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsColorSpectrumVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsColorSpectrumVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsHexInputVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsHexInputVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsHexInputVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_IsMoreButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"IsMoreButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::IsMoreButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_MaxHueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxHueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::MaxHueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_MaxSaturationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxSaturationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::MaxSaturationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_MaxValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MaxValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::MaxValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_MinHueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinHueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::MinHueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_MinSaturationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinSaturationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::MinSaturationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_MinValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"MinValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::MinValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_PreviousColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"PreviousColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::PreviousColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColorPicker::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColorPicker_add_ColorChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ColorPicker, winrt::Microsoft::UI::Xaml::Controls::ColorChangedEventArgs>>(arg);

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

    static PyObject* ColorPicker_remove_ColorChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ColorPicker", L"ColorChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_ColorPicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ColorPicker>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ColorPicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ColorPicker>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ColorPicker[] = {
        { "add_color_changed", reinterpret_cast<PyCFunction>(ColorPicker_add_ColorChanged), METH_O, nullptr },
        { "remove_color_changed", reinterpret_cast<PyCFunction>(ColorPicker_remove_ColorChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_ColorPicker, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ColorPicker), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ColorPicker[] = {
        { "previous_color", reinterpret_cast<getter>(ColorPicker_get_PreviousColor), reinterpret_cast<setter>(ColorPicker_put_PreviousColor), nullptr, nullptr },
        { "min_value", reinterpret_cast<getter>(ColorPicker_get_MinValue), reinterpret_cast<setter>(ColorPicker_put_MinValue), nullptr, nullptr },
        { "min_saturation", reinterpret_cast<getter>(ColorPicker_get_MinSaturation), reinterpret_cast<setter>(ColorPicker_put_MinSaturation), nullptr, nullptr },
        { "min_hue", reinterpret_cast<getter>(ColorPicker_get_MinHue), reinterpret_cast<setter>(ColorPicker_put_MinHue), nullptr, nullptr },
        { "max_value", reinterpret_cast<getter>(ColorPicker_get_MaxValue), reinterpret_cast<setter>(ColorPicker_put_MaxValue), nullptr, nullptr },
        { "max_saturation", reinterpret_cast<getter>(ColorPicker_get_MaxSaturation), reinterpret_cast<setter>(ColorPicker_put_MaxSaturation), nullptr, nullptr },
        { "max_hue", reinterpret_cast<getter>(ColorPicker_get_MaxHue), reinterpret_cast<setter>(ColorPicker_put_MaxHue), nullptr, nullptr },
        { "is_more_button_visible", reinterpret_cast<getter>(ColorPicker_get_IsMoreButtonVisible), reinterpret_cast<setter>(ColorPicker_put_IsMoreButtonVisible), nullptr, nullptr },
        { "is_hex_input_visible", reinterpret_cast<getter>(ColorPicker_get_IsHexInputVisible), reinterpret_cast<setter>(ColorPicker_put_IsHexInputVisible), nullptr, nullptr },
        { "is_color_spectrum_visible", reinterpret_cast<getter>(ColorPicker_get_IsColorSpectrumVisible), reinterpret_cast<setter>(ColorPicker_put_IsColorSpectrumVisible), nullptr, nullptr },
        { "is_color_slider_visible", reinterpret_cast<getter>(ColorPicker_get_IsColorSliderVisible), reinterpret_cast<setter>(ColorPicker_put_IsColorSliderVisible), nullptr, nullptr },
        { "is_color_preview_visible", reinterpret_cast<getter>(ColorPicker_get_IsColorPreviewVisible), reinterpret_cast<setter>(ColorPicker_put_IsColorPreviewVisible), nullptr, nullptr },
        { "is_color_channel_text_input_visible", reinterpret_cast<getter>(ColorPicker_get_IsColorChannelTextInputVisible), reinterpret_cast<setter>(ColorPicker_put_IsColorChannelTextInputVisible), nullptr, nullptr },
        { "is_alpha_text_input_visible", reinterpret_cast<getter>(ColorPicker_get_IsAlphaTextInputVisible), reinterpret_cast<setter>(ColorPicker_put_IsAlphaTextInputVisible), nullptr, nullptr },
        { "is_alpha_slider_visible", reinterpret_cast<getter>(ColorPicker_get_IsAlphaSliderVisible), reinterpret_cast<setter>(ColorPicker_put_IsAlphaSliderVisible), nullptr, nullptr },
        { "is_alpha_enabled", reinterpret_cast<getter>(ColorPicker_get_IsAlphaEnabled), reinterpret_cast<setter>(ColorPicker_put_IsAlphaEnabled), nullptr, nullptr },
        { "color_spectrum_shape", reinterpret_cast<getter>(ColorPicker_get_ColorSpectrumShape), reinterpret_cast<setter>(ColorPicker_put_ColorSpectrumShape), nullptr, nullptr },
        { "color_spectrum_components", reinterpret_cast<getter>(ColorPicker_get_ColorSpectrumComponents), reinterpret_cast<setter>(ColorPicker_put_ColorSpectrumComponents), nullptr, nullptr },
        { "color", reinterpret_cast<getter>(ColorPicker_get_Color), reinterpret_cast<setter>(ColorPicker_put_Color), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(ColorPicker_get_Orientation), reinterpret_cast<setter>(ColorPicker_put_Orientation), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ColorPicker[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ColorPicker) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ColorPicker) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ColorPicker) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ColorPicker) },
        { },
    };

    static PyType_Spec type_spec_ColorPicker =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ColorPicker",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ColorPicker),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ColorPicker
    };

    static PyGetSetDef getset_ColorPicker_Static[] = {
        { "color_property", reinterpret_cast<getter>(ColorPicker_get_ColorProperty), nullptr, nullptr, nullptr },
        { "color_spectrum_components_property", reinterpret_cast<getter>(ColorPicker_get_ColorSpectrumComponentsProperty), nullptr, nullptr, nullptr },
        { "color_spectrum_shape_property", reinterpret_cast<getter>(ColorPicker_get_ColorSpectrumShapeProperty), nullptr, nullptr, nullptr },
        { "is_alpha_enabled_property", reinterpret_cast<getter>(ColorPicker_get_IsAlphaEnabledProperty), nullptr, nullptr, nullptr },
        { "is_alpha_slider_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsAlphaSliderVisibleProperty), nullptr, nullptr, nullptr },
        { "is_alpha_text_input_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsAlphaTextInputVisibleProperty), nullptr, nullptr, nullptr },
        { "is_color_channel_text_input_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsColorChannelTextInputVisibleProperty), nullptr, nullptr, nullptr },
        { "is_color_preview_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsColorPreviewVisibleProperty), nullptr, nullptr, nullptr },
        { "is_color_slider_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsColorSliderVisibleProperty), nullptr, nullptr, nullptr },
        { "is_color_spectrum_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsColorSpectrumVisibleProperty), nullptr, nullptr, nullptr },
        { "is_hex_input_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsHexInputVisibleProperty), nullptr, nullptr, nullptr },
        { "is_more_button_visible_property", reinterpret_cast<getter>(ColorPicker_get_IsMoreButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "max_hue_property", reinterpret_cast<getter>(ColorPicker_get_MaxHueProperty), nullptr, nullptr, nullptr },
        { "max_saturation_property", reinterpret_cast<getter>(ColorPicker_get_MaxSaturationProperty), nullptr, nullptr, nullptr },
        { "max_value_property", reinterpret_cast<getter>(ColorPicker_get_MaxValueProperty), nullptr, nullptr, nullptr },
        { "min_hue_property", reinterpret_cast<getter>(ColorPicker_get_MinHueProperty), nullptr, nullptr, nullptr },
        { "min_saturation_property", reinterpret_cast<getter>(ColorPicker_get_MinSaturationProperty), nullptr, nullptr, nullptr },
        { "min_value_property", reinterpret_cast<getter>(ColorPicker_get_MinValueProperty), nullptr, nullptr, nullptr },
        { "previous_color_property", reinterpret_cast<getter>(ColorPicker_get_PreviousColorProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(ColorPicker_get_OrientationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ColorPicker_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ColorPicker_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ColorPicker_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ColorPicker_Static) },
        { }
    };

    static PyType_Spec type_spec_ColorPicker_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ColorPicker_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ColorPicker_Static
    };

    // ----- ColumnDefinition class --------------------

    static PyObject* _new_ColumnDefinition(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::Microsoft::UI::Xaml::Controls::ColumnDefinition 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_ColumnDefinition(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ColumnDefinition_get_Width(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"Width"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColumnDefinition_put_Width(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"Width"))
        {
            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::Microsoft::UI::Xaml::GridLength>(arg);

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

    static PyObject* ColumnDefinition_get_MinWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"MinWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColumnDefinition_put_MinWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"MinWidth"))
        {
            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<double>(arg);

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

    static PyObject* ColumnDefinition_get_MaxWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"MaxWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ColumnDefinition_put_MaxWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"MaxWidth"))
        {
            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<double>(arg);

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

    static PyObject* ColumnDefinition_get_ActualWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"ActualWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ColumnDefinition_get_MaxWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"MaxWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition::MaxWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColumnDefinition_get_MinWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"MinWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition::MinWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ColumnDefinition_get_WidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinition", L"WidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition::WidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ColumnDefinition(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ColumnDefinition(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ColumnDefinition[] = {
        { "_assign_array_", _assign_array_ColumnDefinition, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ColumnDefinition), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ColumnDefinition[] = {
        { "width", reinterpret_cast<getter>(ColumnDefinition_get_Width), reinterpret_cast<setter>(ColumnDefinition_put_Width), nullptr, nullptr },
        { "min_width", reinterpret_cast<getter>(ColumnDefinition_get_MinWidth), reinterpret_cast<setter>(ColumnDefinition_put_MinWidth), nullptr, nullptr },
        { "max_width", reinterpret_cast<getter>(ColumnDefinition_get_MaxWidth), reinterpret_cast<setter>(ColumnDefinition_put_MaxWidth), nullptr, nullptr },
        { "actual_width", reinterpret_cast<getter>(ColumnDefinition_get_ActualWidth), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ColumnDefinition[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ColumnDefinition) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ColumnDefinition) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ColumnDefinition) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ColumnDefinition) },
        { },
    };

    static PyType_Spec type_spec_ColumnDefinition =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ColumnDefinition",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinition),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ColumnDefinition
    };

    static PyGetSetDef getset_ColumnDefinition_Static[] = {
        { "max_width_property", reinterpret_cast<getter>(ColumnDefinition_get_MaxWidthProperty), nullptr, nullptr, nullptr },
        { "min_width_property", reinterpret_cast<getter>(ColumnDefinition_get_MinWidthProperty), nullptr, nullptr, nullptr },
        { "width_property", reinterpret_cast<getter>(ColumnDefinition_get_WidthProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ColumnDefinition_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ColumnDefinition_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ColumnDefinition_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ColumnDefinition_Static) },
        { }
    };

    static PyType_Spec type_spec_ColumnDefinition_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ColumnDefinition_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ColumnDefinition_Static
    };

    // ----- ColumnDefinitionCollection class --------------------

    static PyObject* _new_ColumnDefinitionCollection(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection>::type_name);
        return nullptr;
    }

    static void _dealloc_ColumnDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ColumnDefinitionCollection_Append(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"Append", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition>(args, 0);

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

    static PyObject* ColumnDefinitionCollection_Clear(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"Clear", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* ColumnDefinitionCollection_First(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", 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* ColumnDefinitionCollection_GetAt(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", 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* ColumnDefinitionCollection_GetMany(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", 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::Microsoft::UI::Xaml::Controls::ColumnDefinition, 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* ColumnDefinitionCollection_GetView(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"GetView", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* ColumnDefinitionCollection_IndexOf(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition>(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* ColumnDefinitionCollection_InsertAt(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"InsertAt", 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::Microsoft::UI::Xaml::Controls::ColumnDefinition>(args, 1);

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

    static PyObject* ColumnDefinitionCollection_RemoveAt(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"RemoveAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* ColumnDefinitionCollection_RemoveAtEnd(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"RemoveAtEnd", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* ColumnDefinitionCollection_ReplaceAll(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"ReplaceAll", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition, false>>(args, 0);

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

    static PyObject* ColumnDefinitionCollection_SetAt(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", L"SetAt", 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::Microsoft::UI::Xaml::Controls::ColumnDefinition>(args, 1);

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

    static PyObject* ColumnDefinitionCollection_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection", 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_ColumnDefinitionCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ColumnDefinitionCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_ColumnDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_ColumnDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_ColumnDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* 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_ColumnDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* 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_ColumnDefinitionCollection(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::Microsoft::UI::Xaml::Controls::ColumnDefinition> items(static_cast<uint32_t>(length), empty_instance<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition>::get());

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

            if (count != static_cast<uint32_t>(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 int _seq_assign_ColumnDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection* self, Py_ssize_t i, PyObject* value) noexcept
    {
        try
        {
            if (value == nullptr) { self->obj.RemoveAt(static_cast<uint32_t>(i)); }
            else { self->obj.SetAt(static_cast<uint32_t>(i), py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ColumnDefinition>(value)); }
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyMethodDef _methods_ColumnDefinitionCollection[] = {
        { "append", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_Append), METH_VARARGS, nullptr },
        { "clear", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_Clear), METH_VARARGS, nullptr },
        { "first", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_GetMany), METH_VARARGS, nullptr },
        { "get_view", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_GetView), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_IndexOf), METH_VARARGS, nullptr },
        { "insert_at", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_InsertAt), METH_VARARGS, nullptr },
        { "remove_at", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_RemoveAt), METH_VARARGS, nullptr },
        { "remove_at_end", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_RemoveAtEnd), METH_VARARGS, nullptr },
        { "replace_all", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_ReplaceAll), METH_VARARGS, nullptr },
        { "set_at", reinterpret_cast<PyCFunction>(ColumnDefinitionCollection_SetAt), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ColumnDefinitionCollection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ColumnDefinitionCollection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ColumnDefinitionCollection[] = {
        { "size", reinterpret_cast<getter>(ColumnDefinitionCollection_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ColumnDefinitionCollection[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ColumnDefinitionCollection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ColumnDefinitionCollection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ColumnDefinitionCollection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ColumnDefinitionCollection) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_ColumnDefinitionCollection) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_ColumnDefinitionCollection) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_ColumnDefinitionCollection) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_ColumnDefinitionCollection) },
        { Py_sq_ass_item, reinterpret_cast<void*>(_seq_assign_ColumnDefinitionCollection) },
        { },
    };

    static PyType_Spec type_spec_ColumnDefinitionCollection =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ColumnDefinitionCollection",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ColumnDefinitionCollection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ColumnDefinitionCollection
    };

    // ----- ComboBox class --------------------

    static PyObject* _new_ComboBox(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::Microsoft::UI::Xaml::Controls::ComboBox 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_ComboBox(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ComboBox_get_TextBoxStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"TextBoxStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_TextBoxStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"TextBoxStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* ComboBox_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBox_get_SelectionChangedTrigger(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"SelectionChangedTrigger"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_SelectionChangedTrigger(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"SelectionChangedTrigger"))
        {
            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::Microsoft::UI::Xaml::Controls::ComboBoxSelectionChangedTrigger>(arg);

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

    static PyObject* ComboBox_get_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"PlaceholderText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"PlaceholderText"))
        {
            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.PlaceholderText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBox_get_PlaceholderForeground(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"PlaceholderForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_PlaceholderForeground(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"PlaceholderForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* ComboBox_get_MaxDropDownHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"MaxDropDownHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_MaxDropDownHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"MaxDropDownHeight"))
        {
            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<double>(arg);

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

    static PyObject* ComboBox_get_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"LightDismissOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"LightDismissOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::LightDismissOverlayMode>(arg);

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

    static PyObject* ComboBox_get_IsTextSearchEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsTextSearchEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_IsTextSearchEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsTextSearchEnabled"))
        {
            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.IsTextSearchEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBox_get_IsEditable(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsEditable"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_IsEditable(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsEditable"))
        {
            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.IsEditable(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBox_get_IsDropDownOpen(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsDropDownOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_IsDropDownOpen(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsDropDownOpen"))
        {
            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.IsDropDownOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBox_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* ComboBox_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBox_get_Description(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"Description"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBox_put_Description(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"Description"))
        {
            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.Description(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBox_get_IsSelectionBoxHighlighted(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsSelectionBoxHighlighted"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ComboBox_get_SelectionBoxItem(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"SelectionBoxItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ComboBox_get_SelectionBoxItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"SelectionBoxItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ComboBox_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ComboBox_get_DescriptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"DescriptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::DescriptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_IsDropDownOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsDropDownOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::IsDropDownOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_IsEditableProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsEditableProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::IsEditableProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_IsTextSearchEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"IsTextSearchEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::IsTextSearchEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_LightDismissOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"LightDismissOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::LightDismissOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_MaxDropDownHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"MaxDropDownHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::MaxDropDownHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_PlaceholderForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"PlaceholderForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::PlaceholderForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_PlaceholderTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"PlaceholderTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::PlaceholderTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_SelectionChangedTriggerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"SelectionChangedTriggerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::SelectionChangedTriggerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_TextBoxStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"TextBoxStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::TextBoxStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ComboBox::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ComboBox_add_DropDownClosed(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"DropDownClosed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ComboBox_remove_DropDownClosed(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"DropDownClosed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ComboBox_add_DropDownOpened(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"DropDownOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ComboBox_remove_DropDownOpened(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"DropDownOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ComboBox_add_TextSubmitted(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"TextSubmitted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ComboBox, winrt::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs>>(arg);

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

    static PyObject* ComboBox_remove_TextSubmitted(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ComboBox", L"TextSubmitted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_ComboBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ComboBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ComboBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ComboBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ComboBox[] = {
        { "add_drop_down_closed", reinterpret_cast<PyCFunction>(ComboBox_add_DropDownClosed), METH_O, nullptr },
        { "remove_drop_down_closed", reinterpret_cast<PyCFunction>(ComboBox_remove_DropDownClosed), METH_O, nullptr },
        { "add_drop_down_opened", reinterpret_cast<PyCFunction>(ComboBox_add_DropDownOpened), METH_O, nullptr },
        { "remove_drop_down_opened", reinterpret_cast<PyCFunction>(ComboBox_remove_DropDownOpened), METH_O, nullptr },
        { "add_text_submitted", reinterpret_cast<PyCFunction>(ComboBox_add_TextSubmitted), METH_O, nullptr },
        { "remove_text_submitted", reinterpret_cast<PyCFunction>(ComboBox_remove_TextSubmitted), METH_O, nullptr },
        { "_assign_array_", _assign_array_ComboBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ComboBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ComboBox[] = {
        { "text_box_style", reinterpret_cast<getter>(ComboBox_get_TextBoxStyle), reinterpret_cast<setter>(ComboBox_put_TextBoxStyle), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(ComboBox_get_Text), reinterpret_cast<setter>(ComboBox_put_Text), nullptr, nullptr },
        { "selection_changed_trigger", reinterpret_cast<getter>(ComboBox_get_SelectionChangedTrigger), reinterpret_cast<setter>(ComboBox_put_SelectionChangedTrigger), nullptr, nullptr },
        { "placeholder_text", reinterpret_cast<getter>(ComboBox_get_PlaceholderText), reinterpret_cast<setter>(ComboBox_put_PlaceholderText), nullptr, nullptr },
        { "placeholder_foreground", reinterpret_cast<getter>(ComboBox_get_PlaceholderForeground), reinterpret_cast<setter>(ComboBox_put_PlaceholderForeground), nullptr, nullptr },
        { "max_drop_down_height", reinterpret_cast<getter>(ComboBox_get_MaxDropDownHeight), reinterpret_cast<setter>(ComboBox_put_MaxDropDownHeight), nullptr, nullptr },
        { "light_dismiss_overlay_mode", reinterpret_cast<getter>(ComboBox_get_LightDismissOverlayMode), reinterpret_cast<setter>(ComboBox_put_LightDismissOverlayMode), nullptr, nullptr },
        { "is_text_search_enabled", reinterpret_cast<getter>(ComboBox_get_IsTextSearchEnabled), reinterpret_cast<setter>(ComboBox_put_IsTextSearchEnabled), nullptr, nullptr },
        { "is_editable", reinterpret_cast<getter>(ComboBox_get_IsEditable), reinterpret_cast<setter>(ComboBox_put_IsEditable), nullptr, nullptr },
        { "is_drop_down_open", reinterpret_cast<getter>(ComboBox_get_IsDropDownOpen), reinterpret_cast<setter>(ComboBox_put_IsDropDownOpen), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(ComboBox_get_HeaderTemplate), reinterpret_cast<setter>(ComboBox_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(ComboBox_get_Header), reinterpret_cast<setter>(ComboBox_put_Header), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(ComboBox_get_Description), reinterpret_cast<setter>(ComboBox_put_Description), nullptr, nullptr },
        { "is_selection_box_highlighted", reinterpret_cast<getter>(ComboBox_get_IsSelectionBoxHighlighted), nullptr, nullptr, nullptr },
        { "selection_box_item", reinterpret_cast<getter>(ComboBox_get_SelectionBoxItem), nullptr, nullptr, nullptr },
        { "selection_box_item_template", reinterpret_cast<getter>(ComboBox_get_SelectionBoxItemTemplate), nullptr, nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(ComboBox_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ComboBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ComboBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ComboBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ComboBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ComboBox) },
        { },
    };

    static PyType_Spec type_spec_ComboBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ComboBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ComboBox
    };

    static PyGetSetDef getset_ComboBox_Static[] = {
        { "description_property", reinterpret_cast<getter>(ComboBox_get_DescriptionProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(ComboBox_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(ComboBox_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_drop_down_open_property", reinterpret_cast<getter>(ComboBox_get_IsDropDownOpenProperty), nullptr, nullptr, nullptr },
        { "is_editable_property", reinterpret_cast<getter>(ComboBox_get_IsEditableProperty), nullptr, nullptr, nullptr },
        { "is_text_search_enabled_property", reinterpret_cast<getter>(ComboBox_get_IsTextSearchEnabledProperty), nullptr, nullptr, nullptr },
        { "light_dismiss_overlay_mode_property", reinterpret_cast<getter>(ComboBox_get_LightDismissOverlayModeProperty), nullptr, nullptr, nullptr },
        { "max_drop_down_height_property", reinterpret_cast<getter>(ComboBox_get_MaxDropDownHeightProperty), nullptr, nullptr, nullptr },
        { "placeholder_foreground_property", reinterpret_cast<getter>(ComboBox_get_PlaceholderForegroundProperty), nullptr, nullptr, nullptr },
        { "placeholder_text_property", reinterpret_cast<getter>(ComboBox_get_PlaceholderTextProperty), nullptr, nullptr, nullptr },
        { "selection_changed_trigger_property", reinterpret_cast<getter>(ComboBox_get_SelectionChangedTriggerProperty), nullptr, nullptr, nullptr },
        { "text_box_style_property", reinterpret_cast<getter>(ComboBox_get_TextBoxStyleProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(ComboBox_get_TextProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ComboBox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ComboBox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ComboBox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ComboBox_Static) },
        { }
    };

    static PyType_Spec type_spec_ComboBox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ComboBox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ComboBox_Static
    };

    // ----- ComboBoxItem class --------------------

    static PyObject* _new_ComboBoxItem(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::Microsoft::UI::Xaml::Controls::ComboBoxItem 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_ComboBoxItem(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBoxItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ComboBoxItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ComboBoxItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ComboBoxItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ComboBoxItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ComboBoxItem[] = {
        { "_assign_array_", _assign_array_ComboBoxItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ComboBoxItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ComboBoxItem[] = {
        { }
    };

    static PyType_Slot _type_slots_ComboBoxItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ComboBoxItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ComboBoxItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ComboBoxItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ComboBoxItem) },
        { },
    };

    static PyType_Spec type_spec_ComboBoxItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ComboBoxItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBoxItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ComboBoxItem
    };

    // ----- ComboBoxTextSubmittedEventArgs class --------------------

    static PyObject* _new_ComboBoxTextSubmittedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ComboBoxTextSubmittedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ComboBoxTextSubmittedEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ComboBoxTextSubmittedEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ComboBoxTextSubmittedEventArgs_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ComboBoxTextSubmittedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ComboBoxTextSubmittedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ComboBoxTextSubmittedEventArgs[] = {
        { "_assign_array_", _assign_array_ComboBoxTextSubmittedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ComboBoxTextSubmittedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ComboBoxTextSubmittedEventArgs[] = {
        { "handled", reinterpret_cast<getter>(ComboBoxTextSubmittedEventArgs_get_Handled), reinterpret_cast<setter>(ComboBoxTextSubmittedEventArgs_put_Handled), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(ComboBoxTextSubmittedEventArgs_get_Text), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ComboBoxTextSubmittedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ComboBoxTextSubmittedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ComboBoxTextSubmittedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ComboBoxTextSubmittedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ComboBoxTextSubmittedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ComboBoxTextSubmittedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ComboBoxTextSubmittedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ComboBoxTextSubmittedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ComboBoxTextSubmittedEventArgs
    };

    // ----- CommandBar class --------------------

    static PyObject* _new_CommandBar(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::Microsoft::UI::Xaml::Controls::CommandBar 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_CommandBar(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CommandBar_get_OverflowButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"OverflowButtonVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CommandBar_put_OverflowButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"OverflowButtonVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::CommandBarOverflowButtonVisibility>(arg);

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

    static PyObject* CommandBar_get_IsDynamicOverflowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"IsDynamicOverflowEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CommandBar_put_IsDynamicOverflowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"IsDynamicOverflowEnabled"))
        {
            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.IsDynamicOverflowEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* CommandBar_get_DefaultLabelPosition(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"DefaultLabelPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CommandBar_put_DefaultLabelPosition(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"DefaultLabelPosition"))
        {
            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::Microsoft::UI::Xaml::Controls::CommandBarDefaultLabelPosition>(arg);

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

    static PyObject* CommandBar_get_CommandBarOverflowPresenterStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"CommandBarOverflowPresenterStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CommandBar_put_CommandBarOverflowPresenterStyle(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"CommandBarOverflowPresenterStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* CommandBar_get_CommandBarTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"CommandBarTemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CommandBar_get_PrimaryCommands(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"PrimaryCommands"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CommandBar_get_SecondaryCommands(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"SecondaryCommands"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CommandBar_get_CommandBarOverflowPresenterStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"CommandBarOverflowPresenterStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CommandBar::CommandBarOverflowPresenterStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CommandBar_get_DefaultLabelPositionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"DefaultLabelPositionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CommandBar::DefaultLabelPositionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CommandBar_get_IsDynamicOverflowEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"IsDynamicOverflowEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CommandBar::IsDynamicOverflowEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CommandBar_get_OverflowButtonVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"OverflowButtonVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CommandBar::OverflowButtonVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CommandBar_get_PrimaryCommandsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"PrimaryCommandsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CommandBar::PrimaryCommandsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CommandBar_get_SecondaryCommandsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"SecondaryCommandsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::CommandBar::SecondaryCommandsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CommandBar_add_DynamicOverflowItemsChanging(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"DynamicOverflowItemsChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::CommandBar, winrt::Microsoft::UI::Xaml::Controls::DynamicOverflowItemsChangingEventArgs>>(arg);

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

    static PyObject* CommandBar_remove_DynamicOverflowItemsChanging(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.CommandBar", L"DynamicOverflowItemsChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_CommandBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CommandBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CommandBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CommandBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CommandBar[] = {
        { "add_dynamic_overflow_items_changing", reinterpret_cast<PyCFunction>(CommandBar_add_DynamicOverflowItemsChanging), METH_O, nullptr },
        { "remove_dynamic_overflow_items_changing", reinterpret_cast<PyCFunction>(CommandBar_remove_DynamicOverflowItemsChanging), METH_O, nullptr },
        { "_assign_array_", _assign_array_CommandBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CommandBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CommandBar[] = {
        { "overflow_button_visibility", reinterpret_cast<getter>(CommandBar_get_OverflowButtonVisibility), reinterpret_cast<setter>(CommandBar_put_OverflowButtonVisibility), nullptr, nullptr },
        { "is_dynamic_overflow_enabled", reinterpret_cast<getter>(CommandBar_get_IsDynamicOverflowEnabled), reinterpret_cast<setter>(CommandBar_put_IsDynamicOverflowEnabled), nullptr, nullptr },
        { "default_label_position", reinterpret_cast<getter>(CommandBar_get_DefaultLabelPosition), reinterpret_cast<setter>(CommandBar_put_DefaultLabelPosition), nullptr, nullptr },
        { "command_bar_overflow_presenter_style", reinterpret_cast<getter>(CommandBar_get_CommandBarOverflowPresenterStyle), reinterpret_cast<setter>(CommandBar_put_CommandBarOverflowPresenterStyle), nullptr, nullptr },
        { "command_bar_template_settings", reinterpret_cast<getter>(CommandBar_get_CommandBarTemplateSettings), nullptr, nullptr, nullptr },
        { "primary_commands", reinterpret_cast<getter>(CommandBar_get_PrimaryCommands), nullptr, nullptr, nullptr },
        { "secondary_commands", reinterpret_cast<getter>(CommandBar_get_SecondaryCommands), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CommandBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CommandBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CommandBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CommandBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CommandBar) },
        { },
    };

    static PyType_Spec type_spec_CommandBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CommandBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CommandBar
    };

    static PyGetSetDef getset_CommandBar_Static[] = {
        { "command_bar_overflow_presenter_style_property", reinterpret_cast<getter>(CommandBar_get_CommandBarOverflowPresenterStyleProperty), nullptr, nullptr, nullptr },
        { "default_label_position_property", reinterpret_cast<getter>(CommandBar_get_DefaultLabelPositionProperty), nullptr, nullptr, nullptr },
        { "is_dynamic_overflow_enabled_property", reinterpret_cast<getter>(CommandBar_get_IsDynamicOverflowEnabledProperty), nullptr, nullptr, nullptr },
        { "overflow_button_visibility_property", reinterpret_cast<getter>(CommandBar_get_OverflowButtonVisibilityProperty), nullptr, nullptr, nullptr },
        { "primary_commands_property", reinterpret_cast<getter>(CommandBar_get_PrimaryCommandsProperty), nullptr, nullptr, nullptr },
        { "secondary_commands_property", reinterpret_cast<getter>(CommandBar_get_SecondaryCommandsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_CommandBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_CommandBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_CommandBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_CommandBar_Static) },
        { }
    };

    static PyType_Spec type_spec_CommandBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CommandBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_CommandBar_Static
    };

    // ----- CommandBarFlyout class --------------------

    static PyObject* _new_CommandBarFlyout(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::Microsoft::UI::Xaml::Controls::CommandBarFlyout 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_CommandBarFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CommandBarFlyout_get_PrimaryCommands(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBarFlyout", L"PrimaryCommands"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CommandBarFlyout_get_SecondaryCommands(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBarFlyout", L"SecondaryCommands"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* CommandBarFlyout_get_AlwaysExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBarFlyout", L"AlwaysExpanded"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int CommandBarFlyout_put_AlwaysExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CommandBarFlyout", L"AlwaysExpanded"))
        {
            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.AlwaysExpanded(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_CommandBarFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CommandBarFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CommandBarFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CommandBarFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CommandBarFlyout[] = {
        { "_assign_array_", _assign_array_CommandBarFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CommandBarFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CommandBarFlyout[] = {
        { "primary_commands", reinterpret_cast<getter>(CommandBarFlyout_get_PrimaryCommands), nullptr, nullptr, nullptr },
        { "secondary_commands", reinterpret_cast<getter>(CommandBarFlyout_get_SecondaryCommands), nullptr, nullptr, nullptr },
        { "always_expanded", reinterpret_cast<getter>(CommandBarFlyout_get_AlwaysExpanded), reinterpret_cast<setter>(CommandBarFlyout_put_AlwaysExpanded), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CommandBarFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CommandBarFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CommandBarFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CommandBarFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CommandBarFlyout) },
        { },
    };

    static PyType_Spec type_spec_CommandBarFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CommandBarFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CommandBarFlyout
    };

    // ----- CommandBarOverflowPresenter class --------------------

    static PyObject* _new_CommandBarOverflowPresenter(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::Microsoft::UI::Xaml::Controls::CommandBarOverflowPresenter 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_CommandBarOverflowPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarOverflowPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_CommandBarOverflowPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CommandBarOverflowPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CommandBarOverflowPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CommandBarOverflowPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CommandBarOverflowPresenter[] = {
        { "_assign_array_", _assign_array_CommandBarOverflowPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CommandBarOverflowPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CommandBarOverflowPresenter[] = {
        { }
    };

    static PyType_Slot _type_slots_CommandBarOverflowPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CommandBarOverflowPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CommandBarOverflowPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CommandBarOverflowPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CommandBarOverflowPresenter) },
        { },
    };

    static PyType_Spec type_spec_CommandBarOverflowPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CommandBarOverflowPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CommandBarOverflowPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CommandBarOverflowPresenter
    };

    // ----- ContainerContentChangingEventArgs class --------------------

    static PyObject* _new_ContainerContentChangingEventArgs(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::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs 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_ContainerContentChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContainerContentChangingEventArgs_RegisterUpdateCallback(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"RegisterUpdateCallback", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ListViewBase, winrt::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs>>(args, 0);

                self->obj.RegisterUpdateCallback(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"RegisterUpdateCallback", 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::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ListViewBase, winrt::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs>>(args, 1);

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

    static PyObject* ContainerContentChangingEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContainerContentChangingEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContainerContentChangingEventArgs_get_InRecycleQueue(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"InRecycleQueue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ContainerContentChangingEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ContainerContentChangingEventArgs_get_ItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"ItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ContainerContentChangingEventArgs_get_ItemIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"ItemIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ContainerContentChangingEventArgs_get_Phase(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs", L"Phase"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ContainerContentChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContainerContentChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContainerContentChangingEventArgs[] = {
        { "register_update_callback", reinterpret_cast<PyCFunction>(ContainerContentChangingEventArgs_RegisterUpdateCallback), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ContainerContentChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContainerContentChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContainerContentChangingEventArgs[] = {
        { "handled", reinterpret_cast<getter>(ContainerContentChangingEventArgs_get_Handled), reinterpret_cast<setter>(ContainerContentChangingEventArgs_put_Handled), nullptr, nullptr },
        { "in_recycle_queue", reinterpret_cast<getter>(ContainerContentChangingEventArgs_get_InRecycleQueue), nullptr, nullptr, nullptr },
        { "item", reinterpret_cast<getter>(ContainerContentChangingEventArgs_get_Item), nullptr, nullptr, nullptr },
        { "item_container", reinterpret_cast<getter>(ContainerContentChangingEventArgs_get_ItemContainer), nullptr, nullptr, nullptr },
        { "item_index", reinterpret_cast<getter>(ContainerContentChangingEventArgs_get_ItemIndex), nullptr, nullptr, nullptr },
        { "phase", reinterpret_cast<getter>(ContainerContentChangingEventArgs_get_Phase), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContainerContentChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContainerContentChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContainerContentChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContainerContentChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContainerContentChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ContainerContentChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContainerContentChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContainerContentChangingEventArgs
    };

    // ----- ContentControl class --------------------

    static PyObject* _new_ContentControl(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::Microsoft::UI::Xaml::Controls::ContentControl 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_ContentControl(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentControl_get_ContentTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentControl_put_ContentTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

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

    static PyObject* ContentControl_get_ContentTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentControl_put_ContentTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

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

    static PyObject* ContentControl_get_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentControl_put_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* ContentControl_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentControl_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"Content"))
        {
            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.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentControl_get_ContentTemplateRoot(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTemplateRoot"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ContentControl_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentControl::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentControl_get_ContentTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentControl::ContentTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentControl_get_ContentTemplateSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTemplateSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentControl::ContentTemplateSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentControl_get_ContentTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentControl", L"ContentTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentControl::ContentTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ContentControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentControl>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentControl[] = {
        { "_assign_array_", _assign_array_ContentControl, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentControl[] = {
        { "content_transitions", reinterpret_cast<getter>(ContentControl_get_ContentTransitions), reinterpret_cast<setter>(ContentControl_put_ContentTransitions), nullptr, nullptr },
        { "content_template_selector", reinterpret_cast<getter>(ContentControl_get_ContentTemplateSelector), reinterpret_cast<setter>(ContentControl_put_ContentTemplateSelector), nullptr, nullptr },
        { "content_template", reinterpret_cast<getter>(ContentControl_get_ContentTemplate), reinterpret_cast<setter>(ContentControl_put_ContentTemplate), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(ContentControl_get_Content), reinterpret_cast<setter>(ContentControl_put_Content), nullptr, nullptr },
        { "content_template_root", reinterpret_cast<getter>(ContentControl_get_ContentTemplateRoot), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContentControl[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentControl) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentControl) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentControl) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentControl) },
        { },
    };

    static PyType_Spec type_spec_ContentControl =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentControl",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentControl
    };

    static PyGetSetDef getset_ContentControl_Static[] = {
        { "content_property", reinterpret_cast<getter>(ContentControl_get_ContentProperty), nullptr, nullptr, nullptr },
        { "content_template_property", reinterpret_cast<getter>(ContentControl_get_ContentTemplateProperty), nullptr, nullptr, nullptr },
        { "content_template_selector_property", reinterpret_cast<getter>(ContentControl_get_ContentTemplateSelectorProperty), nullptr, nullptr, nullptr },
        { "content_transitions_property", reinterpret_cast<getter>(ContentControl_get_ContentTransitionsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ContentControl_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ContentControl_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ContentControl_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ContentControl_Static) },
        { }
    };

    static PyType_Spec type_spec_ContentControl_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentControl_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ContentControl_Static
    };

    // ----- ContentDialog class --------------------

    static PyObject* _new_ContentDialog(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::Microsoft::UI::Xaml::Controls::ContentDialog 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_ContentDialog(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentDialog_Hide(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Hide", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* ContentDialog_ShowAsync(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"ShowAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ShowAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"ShowAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ContentDialogPlacement>(args, 0);

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

    static PyObject* ContentDialog_get_TitleTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"TitleTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_TitleTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"TitleTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* ContentDialog_get_Title(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Title"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_Title(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Title"))
        {
            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.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_SecondaryButtonText(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_SecondaryButtonText(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonText"))
        {
            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.SecondaryButtonText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_SecondaryButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_SecondaryButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* ContentDialog_get_SecondaryButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonCommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_SecondaryButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonCommandParameter"))
        {
            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.SecondaryButtonCommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_SecondaryButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonCommand"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_SecondaryButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonCommand"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

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

    static PyObject* ContentDialog_get_PrimaryButtonText(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_PrimaryButtonText(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonText"))
        {
            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.PrimaryButtonText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_PrimaryButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_PrimaryButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* ContentDialog_get_PrimaryButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonCommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_PrimaryButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonCommandParameter"))
        {
            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.PrimaryButtonCommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_PrimaryButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonCommand"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_PrimaryButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonCommand"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

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

    static PyObject* ContentDialog_get_IsSecondaryButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"IsSecondaryButtonEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_IsSecondaryButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"IsSecondaryButtonEnabled"))
        {
            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.IsSecondaryButtonEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_IsPrimaryButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"IsPrimaryButtonEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_IsPrimaryButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"IsPrimaryButtonEnabled"))
        {
            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.IsPrimaryButtonEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_FullSizeDesired(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"FullSizeDesired"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_FullSizeDesired(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"FullSizeDesired"))
        {
            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.FullSizeDesired(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_DefaultButton(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"DefaultButton"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_DefaultButton(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"DefaultButton"))
        {
            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::Microsoft::UI::Xaml::Controls::ContentDialogButton>(arg);

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

    static PyObject* ContentDialog_get_CloseButtonText(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_CloseButtonText(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonText"))
        {
            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.CloseButtonText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_CloseButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_CloseButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* ContentDialog_get_CloseButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonCommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_CloseButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonCommandParameter"))
        {
            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.CloseButtonCommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialog_get_CloseButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonCommand"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialog_put_CloseButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonCommand"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

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

    static PyObject* ContentDialog_get_CloseButtonCommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonCommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::CloseButtonCommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_CloseButtonCommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonCommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::CloseButtonCommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_CloseButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::CloseButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_CloseButtonTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::CloseButtonTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_DefaultButtonProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"DefaultButtonProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::DefaultButtonProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_FullSizeDesiredProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"FullSizeDesiredProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::FullSizeDesiredProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_IsPrimaryButtonEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"IsPrimaryButtonEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::IsPrimaryButtonEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_IsSecondaryButtonEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"IsSecondaryButtonEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::IsSecondaryButtonEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_PrimaryButtonCommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonCommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::PrimaryButtonCommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_PrimaryButtonCommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonCommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::PrimaryButtonCommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_PrimaryButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::PrimaryButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_PrimaryButtonTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::PrimaryButtonTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_SecondaryButtonCommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonCommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::SecondaryButtonCommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_SecondaryButtonCommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonCommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::SecondaryButtonCommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_SecondaryButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::SecondaryButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_SecondaryButtonTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::SecondaryButtonTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_TitleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"TitleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::TitleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_get_TitleTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"TitleTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentDialog::TitleTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentDialog_add_CloseButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ContentDialog, winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs>>(arg);

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

    static PyObject* ContentDialog_remove_CloseButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"CloseButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ContentDialog_add_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ContentDialog, winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs>>(arg);

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

    static PyObject* ContentDialog_remove_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ContentDialog_add_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ContentDialog, winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs>>(arg);

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

    static PyObject* ContentDialog_remove_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ContentDialog_add_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ContentDialog, winrt::Microsoft::UI::Xaml::Controls::ContentDialogOpenedEventArgs>>(arg);

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

    static PyObject* ContentDialog_remove_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ContentDialog_add_PrimaryButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ContentDialog, winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs>>(arg);

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

    static PyObject* ContentDialog_remove_PrimaryButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"PrimaryButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* ContentDialog_add_SecondaryButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ContentDialog, winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs>>(arg);

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

    static PyObject* ContentDialog_remove_SecondaryButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ContentDialog", L"SecondaryButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_ContentDialog(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentDialog>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentDialog(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentDialog>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentDialog[] = {
        { "hide", reinterpret_cast<PyCFunction>(ContentDialog_Hide), METH_VARARGS, nullptr },
        { "show_async", reinterpret_cast<PyCFunction>(ContentDialog_ShowAsync), METH_VARARGS, nullptr },
        { "add_close_button_click", reinterpret_cast<PyCFunction>(ContentDialog_add_CloseButtonClick), METH_O, nullptr },
        { "remove_close_button_click", reinterpret_cast<PyCFunction>(ContentDialog_remove_CloseButtonClick), METH_O, nullptr },
        { "add_closed", reinterpret_cast<PyCFunction>(ContentDialog_add_Closed), METH_O, nullptr },
        { "remove_closed", reinterpret_cast<PyCFunction>(ContentDialog_remove_Closed), METH_O, nullptr },
        { "add_closing", reinterpret_cast<PyCFunction>(ContentDialog_add_Closing), METH_O, nullptr },
        { "remove_closing", reinterpret_cast<PyCFunction>(ContentDialog_remove_Closing), METH_O, nullptr },
        { "add_opened", reinterpret_cast<PyCFunction>(ContentDialog_add_Opened), METH_O, nullptr },
        { "remove_opened", reinterpret_cast<PyCFunction>(ContentDialog_remove_Opened), METH_O, nullptr },
        { "add_primary_button_click", reinterpret_cast<PyCFunction>(ContentDialog_add_PrimaryButtonClick), METH_O, nullptr },
        { "remove_primary_button_click", reinterpret_cast<PyCFunction>(ContentDialog_remove_PrimaryButtonClick), METH_O, nullptr },
        { "add_secondary_button_click", reinterpret_cast<PyCFunction>(ContentDialog_add_SecondaryButtonClick), METH_O, nullptr },
        { "remove_secondary_button_click", reinterpret_cast<PyCFunction>(ContentDialog_remove_SecondaryButtonClick), METH_O, nullptr },
        { "_assign_array_", _assign_array_ContentDialog, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentDialog), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentDialog[] = {
        { "title_template", reinterpret_cast<getter>(ContentDialog_get_TitleTemplate), reinterpret_cast<setter>(ContentDialog_put_TitleTemplate), nullptr, nullptr },
        { "title", reinterpret_cast<getter>(ContentDialog_get_Title), reinterpret_cast<setter>(ContentDialog_put_Title), nullptr, nullptr },
        { "secondary_button_text", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonText), reinterpret_cast<setter>(ContentDialog_put_SecondaryButtonText), nullptr, nullptr },
        { "secondary_button_style", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonStyle), reinterpret_cast<setter>(ContentDialog_put_SecondaryButtonStyle), nullptr, nullptr },
        { "secondary_button_command_parameter", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonCommandParameter), reinterpret_cast<setter>(ContentDialog_put_SecondaryButtonCommandParameter), nullptr, nullptr },
        { "secondary_button_command", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonCommand), reinterpret_cast<setter>(ContentDialog_put_SecondaryButtonCommand), nullptr, nullptr },
        { "primary_button_text", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonText), reinterpret_cast<setter>(ContentDialog_put_PrimaryButtonText), nullptr, nullptr },
        { "primary_button_style", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonStyle), reinterpret_cast<setter>(ContentDialog_put_PrimaryButtonStyle), nullptr, nullptr },
        { "primary_button_command_parameter", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonCommandParameter), reinterpret_cast<setter>(ContentDialog_put_PrimaryButtonCommandParameter), nullptr, nullptr },
        { "primary_button_command", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonCommand), reinterpret_cast<setter>(ContentDialog_put_PrimaryButtonCommand), nullptr, nullptr },
        { "is_secondary_button_enabled", reinterpret_cast<getter>(ContentDialog_get_IsSecondaryButtonEnabled), reinterpret_cast<setter>(ContentDialog_put_IsSecondaryButtonEnabled), nullptr, nullptr },
        { "is_primary_button_enabled", reinterpret_cast<getter>(ContentDialog_get_IsPrimaryButtonEnabled), reinterpret_cast<setter>(ContentDialog_put_IsPrimaryButtonEnabled), nullptr, nullptr },
        { "full_size_desired", reinterpret_cast<getter>(ContentDialog_get_FullSizeDesired), reinterpret_cast<setter>(ContentDialog_put_FullSizeDesired), nullptr, nullptr },
        { "default_button", reinterpret_cast<getter>(ContentDialog_get_DefaultButton), reinterpret_cast<setter>(ContentDialog_put_DefaultButton), nullptr, nullptr },
        { "close_button_text", reinterpret_cast<getter>(ContentDialog_get_CloseButtonText), reinterpret_cast<setter>(ContentDialog_put_CloseButtonText), nullptr, nullptr },
        { "close_button_style", reinterpret_cast<getter>(ContentDialog_get_CloseButtonStyle), reinterpret_cast<setter>(ContentDialog_put_CloseButtonStyle), nullptr, nullptr },
        { "close_button_command_parameter", reinterpret_cast<getter>(ContentDialog_get_CloseButtonCommandParameter), reinterpret_cast<setter>(ContentDialog_put_CloseButtonCommandParameter), nullptr, nullptr },
        { "close_button_command", reinterpret_cast<getter>(ContentDialog_get_CloseButtonCommand), reinterpret_cast<setter>(ContentDialog_put_CloseButtonCommand), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContentDialog[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentDialog) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentDialog) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentDialog) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentDialog) },
        { },
    };

    static PyType_Spec type_spec_ContentDialog =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialog",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialog),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentDialog
    };

    static PyGetSetDef getset_ContentDialog_Static[] = {
        { "close_button_command_parameter_property", reinterpret_cast<getter>(ContentDialog_get_CloseButtonCommandParameterProperty), nullptr, nullptr, nullptr },
        { "close_button_command_property", reinterpret_cast<getter>(ContentDialog_get_CloseButtonCommandProperty), nullptr, nullptr, nullptr },
        { "close_button_style_property", reinterpret_cast<getter>(ContentDialog_get_CloseButtonStyleProperty), nullptr, nullptr, nullptr },
        { "close_button_text_property", reinterpret_cast<getter>(ContentDialog_get_CloseButtonTextProperty), nullptr, nullptr, nullptr },
        { "default_button_property", reinterpret_cast<getter>(ContentDialog_get_DefaultButtonProperty), nullptr, nullptr, nullptr },
        { "full_size_desired_property", reinterpret_cast<getter>(ContentDialog_get_FullSizeDesiredProperty), nullptr, nullptr, nullptr },
        { "is_primary_button_enabled_property", reinterpret_cast<getter>(ContentDialog_get_IsPrimaryButtonEnabledProperty), nullptr, nullptr, nullptr },
        { "is_secondary_button_enabled_property", reinterpret_cast<getter>(ContentDialog_get_IsSecondaryButtonEnabledProperty), nullptr, nullptr, nullptr },
        { "primary_button_command_parameter_property", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonCommandParameterProperty), nullptr, nullptr, nullptr },
        { "primary_button_command_property", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonCommandProperty), nullptr, nullptr, nullptr },
        { "primary_button_style_property", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonStyleProperty), nullptr, nullptr, nullptr },
        { "primary_button_text_property", reinterpret_cast<getter>(ContentDialog_get_PrimaryButtonTextProperty), nullptr, nullptr, nullptr },
        { "secondary_button_command_parameter_property", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonCommandParameterProperty), nullptr, nullptr, nullptr },
        { "secondary_button_command_property", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonCommandProperty), nullptr, nullptr, nullptr },
        { "secondary_button_style_property", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonStyleProperty), nullptr, nullptr, nullptr },
        { "secondary_button_text_property", reinterpret_cast<getter>(ContentDialog_get_SecondaryButtonTextProperty), nullptr, nullptr, nullptr },
        { "title_property", reinterpret_cast<getter>(ContentDialog_get_TitleProperty), nullptr, nullptr, nullptr },
        { "title_template_property", reinterpret_cast<getter>(ContentDialog_get_TitleTemplateProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ContentDialog_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ContentDialog_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ContentDialog_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ContentDialog_Static) },
        { }
    };

    static PyType_Spec type_spec_ContentDialog_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialog_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ContentDialog_Static
    };

    // ----- ContentDialogButtonClickDeferral class --------------------

    static PyObject* _new_ContentDialogButtonClickDeferral(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickDeferral>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickDeferral>::type_name);
        return nullptr;
    }

    static void _dealloc_ContentDialogButtonClickDeferral(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickDeferral* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentDialogButtonClickDeferral_Complete(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickDeferral* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogButtonClickDeferral", L"Complete", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* _assign_array_ContentDialogButtonClickDeferral(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickDeferral>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentDialogButtonClickDeferral(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickDeferral>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentDialogButtonClickDeferral[] = {
        { "complete", reinterpret_cast<PyCFunction>(ContentDialogButtonClickDeferral_Complete), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ContentDialogButtonClickDeferral, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentDialogButtonClickDeferral), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentDialogButtonClickDeferral[] = {
        { }
    };

    static PyType_Slot _type_slots_ContentDialogButtonClickDeferral[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentDialogButtonClickDeferral) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentDialogButtonClickDeferral) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentDialogButtonClickDeferral) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentDialogButtonClickDeferral) },
        { },
    };

    static PyType_Spec type_spec_ContentDialogButtonClickDeferral =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialogButtonClickDeferral",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickDeferral),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentDialogButtonClickDeferral
    };

    // ----- ContentDialogButtonClickEventArgs class --------------------

    static PyObject* _new_ContentDialogButtonClickEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ContentDialogButtonClickEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentDialogButtonClickEventArgs_GetDeferral(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogButtonClickEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* ContentDialogButtonClickEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogButtonClickEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialogButtonClickEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogButtonClickEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_ContentDialogButtonClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentDialogButtonClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentDialogButtonClickEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(ContentDialogButtonClickEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ContentDialogButtonClickEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentDialogButtonClickEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentDialogButtonClickEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(ContentDialogButtonClickEventArgs_get_Cancel), reinterpret_cast<setter>(ContentDialogButtonClickEventArgs_put_Cancel), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContentDialogButtonClickEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentDialogButtonClickEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentDialogButtonClickEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentDialogButtonClickEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentDialogButtonClickEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ContentDialogButtonClickEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialogButtonClickEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogButtonClickEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentDialogButtonClickEventArgs
    };

    // ----- ContentDialogClosedEventArgs class --------------------

    static PyObject* _new_ContentDialogClosedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ContentDialogClosedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentDialogClosedEventArgs_get_Result(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogClosedEventArgs", L"Result"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ContentDialogClosedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentDialogClosedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentDialogClosedEventArgs[] = {
        { "_assign_array_", _assign_array_ContentDialogClosedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentDialogClosedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentDialogClosedEventArgs[] = {
        { "result", reinterpret_cast<getter>(ContentDialogClosedEventArgs_get_Result), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContentDialogClosedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentDialogClosedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentDialogClosedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentDialogClosedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentDialogClosedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ContentDialogClosedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialogClosedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentDialogClosedEventArgs
    };

    // ----- ContentDialogClosingDeferral class --------------------

    static PyObject* _new_ContentDialogClosingDeferral(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingDeferral>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingDeferral>::type_name);
        return nullptr;
    }

    static void _dealloc_ContentDialogClosingDeferral(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingDeferral* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentDialogClosingDeferral_Complete(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingDeferral* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogClosingDeferral", L"Complete", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* _assign_array_ContentDialogClosingDeferral(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingDeferral>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentDialogClosingDeferral(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingDeferral>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentDialogClosingDeferral[] = {
        { "complete", reinterpret_cast<PyCFunction>(ContentDialogClosingDeferral_Complete), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ContentDialogClosingDeferral, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentDialogClosingDeferral), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentDialogClosingDeferral[] = {
        { }
    };

    static PyType_Slot _type_slots_ContentDialogClosingDeferral[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentDialogClosingDeferral) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentDialogClosingDeferral) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentDialogClosingDeferral) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentDialogClosingDeferral) },
        { },
    };

    static PyType_Spec type_spec_ContentDialogClosingDeferral =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialogClosingDeferral",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingDeferral),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentDialogClosingDeferral
    };

    // ----- ContentDialogClosingEventArgs class --------------------

    static PyObject* _new_ContentDialogClosingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ContentDialogClosingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentDialogClosingEventArgs_GetDeferral(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogClosingEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* ContentDialogClosingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogClosingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentDialogClosingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogClosingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentDialogClosingEventArgs_get_Result(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentDialogClosingEventArgs", L"Result"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ContentDialogClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentDialogClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentDialogClosingEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(ContentDialogClosingEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ContentDialogClosingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentDialogClosingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentDialogClosingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(ContentDialogClosingEventArgs_get_Cancel), reinterpret_cast<setter>(ContentDialogClosingEventArgs_put_Cancel), nullptr, nullptr },
        { "result", reinterpret_cast<getter>(ContentDialogClosingEventArgs_get_Result), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContentDialogClosingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentDialogClosingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentDialogClosingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentDialogClosingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentDialogClosingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ContentDialogClosingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialogClosingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogClosingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentDialogClosingEventArgs
    };

    // ----- ContentDialogOpenedEventArgs class --------------------

    static PyObject* _new_ContentDialogOpenedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogOpenedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContentDialogOpenedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ContentDialogOpenedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogOpenedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ContentDialogOpenedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentDialogOpenedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentDialogOpenedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentDialogOpenedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentDialogOpenedEventArgs[] = {
        { "_assign_array_", _assign_array_ContentDialogOpenedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentDialogOpenedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentDialogOpenedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_ContentDialogOpenedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentDialogOpenedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentDialogOpenedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentDialogOpenedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentDialogOpenedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ContentDialogOpenedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentDialogOpenedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentDialogOpenedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentDialogOpenedEventArgs
    };

    // ----- ContentPresenter class --------------------

    static PyObject* _new_ContentPresenter(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::Microsoft::UI::Xaml::Controls::ContentPresenter 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_ContentPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContentPresenter_get_VerticalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"VerticalContentAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_VerticalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"VerticalContentAlignment"))
        {
            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::Microsoft::UI::Xaml::VerticalAlignment>(arg);

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

    static PyObject* ContentPresenter_get_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"TextWrapping"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"TextWrapping"))
        {
            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::Microsoft::UI::Xaml::TextWrapping>(arg);

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

    static PyObject* ContentPresenter_get_TextLineBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"TextLineBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_TextLineBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"TextLineBounds"))
        {
            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::Microsoft::UI::Xaml::TextLineBounds>(arg);

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

    static PyObject* ContentPresenter_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* ContentPresenter_get_OpticalMarginAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"OpticalMarginAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_OpticalMarginAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"OpticalMarginAlignment"))
        {
            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::Microsoft::UI::Xaml::OpticalMarginAlignment>(arg);

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

    static PyObject* ContentPresenter_get_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"MaxLines"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"MaxLines"))
        {
            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<int32_t>(arg);

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

    static PyObject* ContentPresenter_get_LineStackingStrategy(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"LineStackingStrategy"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_LineStackingStrategy(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"LineStackingStrategy"))
        {
            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::Microsoft::UI::Xaml::LineStackingStrategy>(arg);

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

    static PyObject* ContentPresenter_get_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"LineHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"LineHeight"))
        {
            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<double>(arg);

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

    static PyObject* ContentPresenter_get_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"IsTextScaleFactorEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"IsTextScaleFactorEnabled"))
        {
            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.IsTextScaleFactorEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentPresenter_get_HorizontalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"HorizontalContentAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_HorizontalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"HorizontalContentAlignment"))
        {
            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::Microsoft::UI::Xaml::HorizontalAlignment>(arg);

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

    static PyObject* ContentPresenter_get_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Foreground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Foreground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* ContentPresenter_get_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* ContentPresenter_get_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* ContentPresenter_get_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontStretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontStretch"))
        {
            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::UI::Text::FontStretch>(arg);

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

    static PyObject* ContentPresenter_get_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontSize"))
        {
            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<double>(arg);

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

    static PyObject* ContentPresenter_get_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* ContentPresenter_get_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"CornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"CornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

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

    static PyObject* ContentPresenter_get_ContentTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_ContentTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

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

    static PyObject* ContentPresenter_get_ContentTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_ContentTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

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

    static PyObject* ContentPresenter_get_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* ContentPresenter_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Content"))
        {
            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.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContentPresenter_get_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"CharacterSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"CharacterSpacing"))
        {
            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<int32_t>(arg);

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

    static PyObject* ContentPresenter_get_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BorderThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BorderThickness"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* ContentPresenter_get_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* ContentPresenter_get_BackgroundTransition(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BackgroundTransition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_BackgroundTransition(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BackgroundTransition"))
        {
            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::Microsoft::UI::Xaml::BrushTransition>(arg);

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

    static PyObject* ContentPresenter_get_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BackgroundSizing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BackgroundSizing"))
        {
            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::Microsoft::UI::Xaml::Controls::BackgroundSizing>(arg);

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

    static PyObject* ContentPresenter_get_Background(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Background"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContentPresenter_put_Background(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"Background"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* ContentPresenter_get_BackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::BackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_BackgroundSizingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BackgroundSizingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::BackgroundSizingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_BorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::BorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_BorderThicknessProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"BorderThicknessProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::BorderThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_CharacterSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"CharacterSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::CharacterSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_ContentTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::ContentTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_ContentTemplateSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTemplateSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::ContentTemplateSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_ContentTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ContentTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::ContentTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_CornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"CornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::CornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_FontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::FontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_FontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::FontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_FontStretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontStretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::FontStretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_FontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::FontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_FontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"FontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::FontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_ForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"ForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::ForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_HorizontalContentAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"HorizontalContentAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::HorizontalContentAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_IsTextScaleFactorEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"IsTextScaleFactorEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::IsTextScaleFactorEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_LineHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"LineHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::LineHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_LineStackingStrategyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"LineStackingStrategyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::LineStackingStrategyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_MaxLinesProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"MaxLinesProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::MaxLinesProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_OpticalMarginAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"OpticalMarginAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::OpticalMarginAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_TextLineBoundsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"TextLineBoundsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::TextLineBoundsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_TextWrappingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"TextWrappingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::TextWrappingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ContentPresenter_get_VerticalContentAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContentPresenter", L"VerticalContentAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ContentPresenter::VerticalContentAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ContentPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContentPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContentPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContentPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContentPresenter[] = {
        { "_assign_array_", _assign_array_ContentPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContentPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContentPresenter[] = {
        { "vertical_content_alignment", reinterpret_cast<getter>(ContentPresenter_get_VerticalContentAlignment), reinterpret_cast<setter>(ContentPresenter_put_VerticalContentAlignment), nullptr, nullptr },
        { "text_wrapping", reinterpret_cast<getter>(ContentPresenter_get_TextWrapping), reinterpret_cast<setter>(ContentPresenter_put_TextWrapping), nullptr, nullptr },
        { "text_line_bounds", reinterpret_cast<getter>(ContentPresenter_get_TextLineBounds), reinterpret_cast<setter>(ContentPresenter_put_TextLineBounds), nullptr, nullptr },
        { "padding", reinterpret_cast<getter>(ContentPresenter_get_Padding), reinterpret_cast<setter>(ContentPresenter_put_Padding), nullptr, nullptr },
        { "optical_margin_alignment", reinterpret_cast<getter>(ContentPresenter_get_OpticalMarginAlignment), reinterpret_cast<setter>(ContentPresenter_put_OpticalMarginAlignment), nullptr, nullptr },
        { "max_lines", reinterpret_cast<getter>(ContentPresenter_get_MaxLines), reinterpret_cast<setter>(ContentPresenter_put_MaxLines), nullptr, nullptr },
        { "line_stacking_strategy", reinterpret_cast<getter>(ContentPresenter_get_LineStackingStrategy), reinterpret_cast<setter>(ContentPresenter_put_LineStackingStrategy), nullptr, nullptr },
        { "line_height", reinterpret_cast<getter>(ContentPresenter_get_LineHeight), reinterpret_cast<setter>(ContentPresenter_put_LineHeight), nullptr, nullptr },
        { "is_text_scale_factor_enabled", reinterpret_cast<getter>(ContentPresenter_get_IsTextScaleFactorEnabled), reinterpret_cast<setter>(ContentPresenter_put_IsTextScaleFactorEnabled), nullptr, nullptr },
        { "horizontal_content_alignment", reinterpret_cast<getter>(ContentPresenter_get_HorizontalContentAlignment), reinterpret_cast<setter>(ContentPresenter_put_HorizontalContentAlignment), nullptr, nullptr },
        { "foreground", reinterpret_cast<getter>(ContentPresenter_get_Foreground), reinterpret_cast<setter>(ContentPresenter_put_Foreground), nullptr, nullptr },
        { "font_weight", reinterpret_cast<getter>(ContentPresenter_get_FontWeight), reinterpret_cast<setter>(ContentPresenter_put_FontWeight), nullptr, nullptr },
        { "font_style", reinterpret_cast<getter>(ContentPresenter_get_FontStyle), reinterpret_cast<setter>(ContentPresenter_put_FontStyle), nullptr, nullptr },
        { "font_stretch", reinterpret_cast<getter>(ContentPresenter_get_FontStretch), reinterpret_cast<setter>(ContentPresenter_put_FontStretch), nullptr, nullptr },
        { "font_size", reinterpret_cast<getter>(ContentPresenter_get_FontSize), reinterpret_cast<setter>(ContentPresenter_put_FontSize), nullptr, nullptr },
        { "font_family", reinterpret_cast<getter>(ContentPresenter_get_FontFamily), reinterpret_cast<setter>(ContentPresenter_put_FontFamily), nullptr, nullptr },
        { "corner_radius", reinterpret_cast<getter>(ContentPresenter_get_CornerRadius), reinterpret_cast<setter>(ContentPresenter_put_CornerRadius), nullptr, nullptr },
        { "content_transitions", reinterpret_cast<getter>(ContentPresenter_get_ContentTransitions), reinterpret_cast<setter>(ContentPresenter_put_ContentTransitions), nullptr, nullptr },
        { "content_template_selector", reinterpret_cast<getter>(ContentPresenter_get_ContentTemplateSelector), reinterpret_cast<setter>(ContentPresenter_put_ContentTemplateSelector), nullptr, nullptr },
        { "content_template", reinterpret_cast<getter>(ContentPresenter_get_ContentTemplate), reinterpret_cast<setter>(ContentPresenter_put_ContentTemplate), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(ContentPresenter_get_Content), reinterpret_cast<setter>(ContentPresenter_put_Content), nullptr, nullptr },
        { "character_spacing", reinterpret_cast<getter>(ContentPresenter_get_CharacterSpacing), reinterpret_cast<setter>(ContentPresenter_put_CharacterSpacing), nullptr, nullptr },
        { "border_thickness", reinterpret_cast<getter>(ContentPresenter_get_BorderThickness), reinterpret_cast<setter>(ContentPresenter_put_BorderThickness), nullptr, nullptr },
        { "border_brush", reinterpret_cast<getter>(ContentPresenter_get_BorderBrush), reinterpret_cast<setter>(ContentPresenter_put_BorderBrush), nullptr, nullptr },
        { "background_transition", reinterpret_cast<getter>(ContentPresenter_get_BackgroundTransition), reinterpret_cast<setter>(ContentPresenter_put_BackgroundTransition), nullptr, nullptr },
        { "background_sizing", reinterpret_cast<getter>(ContentPresenter_get_BackgroundSizing), reinterpret_cast<setter>(ContentPresenter_put_BackgroundSizing), nullptr, nullptr },
        { "background", reinterpret_cast<getter>(ContentPresenter_get_Background), reinterpret_cast<setter>(ContentPresenter_put_Background), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContentPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContentPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContentPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContentPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContentPresenter) },
        { },
    };

    static PyType_Spec type_spec_ContentPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContentPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContentPresenter
    };

    static PyGetSetDef getset_ContentPresenter_Static[] = {
        { "background_property", reinterpret_cast<getter>(ContentPresenter_get_BackgroundProperty), nullptr, nullptr, nullptr },
        { "background_sizing_property", reinterpret_cast<getter>(ContentPresenter_get_BackgroundSizingProperty), nullptr, nullptr, nullptr },
        { "border_brush_property", reinterpret_cast<getter>(ContentPresenter_get_BorderBrushProperty), nullptr, nullptr, nullptr },
        { "border_thickness_property", reinterpret_cast<getter>(ContentPresenter_get_BorderThicknessProperty), nullptr, nullptr, nullptr },
        { "character_spacing_property", reinterpret_cast<getter>(ContentPresenter_get_CharacterSpacingProperty), nullptr, nullptr, nullptr },
        { "content_property", reinterpret_cast<getter>(ContentPresenter_get_ContentProperty), nullptr, nullptr, nullptr },
        { "content_template_property", reinterpret_cast<getter>(ContentPresenter_get_ContentTemplateProperty), nullptr, nullptr, nullptr },
        { "content_template_selector_property", reinterpret_cast<getter>(ContentPresenter_get_ContentTemplateSelectorProperty), nullptr, nullptr, nullptr },
        { "content_transitions_property", reinterpret_cast<getter>(ContentPresenter_get_ContentTransitionsProperty), nullptr, nullptr, nullptr },
        { "corner_radius_property", reinterpret_cast<getter>(ContentPresenter_get_CornerRadiusProperty), nullptr, nullptr, nullptr },
        { "font_family_property", reinterpret_cast<getter>(ContentPresenter_get_FontFamilyProperty), nullptr, nullptr, nullptr },
        { "font_size_property", reinterpret_cast<getter>(ContentPresenter_get_FontSizeProperty), nullptr, nullptr, nullptr },
        { "font_stretch_property", reinterpret_cast<getter>(ContentPresenter_get_FontStretchProperty), nullptr, nullptr, nullptr },
        { "font_style_property", reinterpret_cast<getter>(ContentPresenter_get_FontStyleProperty), nullptr, nullptr, nullptr },
        { "font_weight_property", reinterpret_cast<getter>(ContentPresenter_get_FontWeightProperty), nullptr, nullptr, nullptr },
        { "foreground_property", reinterpret_cast<getter>(ContentPresenter_get_ForegroundProperty), nullptr, nullptr, nullptr },
        { "horizontal_content_alignment_property", reinterpret_cast<getter>(ContentPresenter_get_HorizontalContentAlignmentProperty), nullptr, nullptr, nullptr },
        { "is_text_scale_factor_enabled_property", reinterpret_cast<getter>(ContentPresenter_get_IsTextScaleFactorEnabledProperty), nullptr, nullptr, nullptr },
        { "line_height_property", reinterpret_cast<getter>(ContentPresenter_get_LineHeightProperty), nullptr, nullptr, nullptr },
        { "line_stacking_strategy_property", reinterpret_cast<getter>(ContentPresenter_get_LineStackingStrategyProperty), nullptr, nullptr, nullptr },
        { "max_lines_property", reinterpret_cast<getter>(ContentPresenter_get_MaxLinesProperty), nullptr, nullptr, nullptr },
        { "optical_margin_alignment_property", reinterpret_cast<getter>(ContentPresenter_get_OpticalMarginAlignmentProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(ContentPresenter_get_PaddingProperty), nullptr, nullptr, nullptr },
        { "text_line_bounds_property", reinterpret_cast<getter>(ContentPresenter_get_TextLineBoundsProperty), nullptr, nullptr, nullptr },
        { "text_wrapping_property", reinterpret_cast<getter>(ContentPresenter_get_TextWrappingProperty), nullptr, nullptr, nullptr },
        { "vertical_content_alignment_property", reinterpret_cast<getter>(ContentPresenter_get_VerticalContentAlignmentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ContentPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ContentPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ContentPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ContentPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_ContentPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContentPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ContentPresenter_Static
    };

    // ----- ContextMenuEventArgs class --------------------

    static PyObject* _new_ContextMenuEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ContextMenuEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ContextMenuEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContextMenuEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ContextMenuEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContextMenuEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ContextMenuEventArgs_get_CursorLeft(py::wrapper::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContextMenuEventArgs", L"CursorLeft"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ContextMenuEventArgs_get_CursorTop(py::wrapper::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ContextMenuEventArgs", L"CursorTop"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ContextMenuEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ContextMenuEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ContextMenuEventArgs[] = {
        { "_assign_array_", _assign_array_ContextMenuEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ContextMenuEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ContextMenuEventArgs[] = {
        { "handled", reinterpret_cast<getter>(ContextMenuEventArgs_get_Handled), reinterpret_cast<setter>(ContextMenuEventArgs_put_Handled), nullptr, nullptr },
        { "cursor_left", reinterpret_cast<getter>(ContextMenuEventArgs_get_CursorLeft), nullptr, nullptr, nullptr },
        { "cursor_top", reinterpret_cast<getter>(ContextMenuEventArgs_get_CursorTop), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ContextMenuEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ContextMenuEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ContextMenuEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ContextMenuEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ContextMenuEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ContextMenuEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ContextMenuEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ContextMenuEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ContextMenuEventArgs
    };

    // ----- Control class --------------------

    static PyObject* _new_Control(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::Control>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::Control>::type_name);
        return nullptr;
    }

    static void _dealloc_Control(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Control_ApplyTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Control", L"ApplyTemplate", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* Control_GetIsTemplateFocusTarget(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Control", L"GetIsTemplateFocusTarget", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::GetIsTemplateFocusTarget(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Control_GetIsTemplateKeyTipTarget(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Control", L"GetIsTemplateKeyTipTarget", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::GetIsTemplateKeyTipTarget(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Control_RemoveFocusEngagement(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Control", L"RemoveFocusEngagement", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* Control_SetIsTemplateFocusTarget(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Control", L"SetIsTemplateFocusTarget", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Control::SetIsTemplateFocusTarget(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Control_SetIsTemplateKeyTipTarget(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Control", L"SetIsTemplateKeyTipTarget", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Control::SetIsTemplateKeyTipTarget(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Control_get_VerticalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"VerticalContentAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_VerticalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"VerticalContentAlignment"))
        {
            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::Microsoft::UI::Xaml::VerticalAlignment>(arg);

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

    static PyObject* Control_get_Template(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Template"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_Template(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Template"))
        {
            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::Microsoft::UI::Xaml::Controls::ControlTemplate>(arg);

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

    static PyObject* Control_get_TabNavigation(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"TabNavigation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_TabNavigation(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"TabNavigation"))
        {
            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::Microsoft::UI::Xaml::Input::KeyboardNavigationMode>(arg);

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

    static PyObject* Control_get_RequiresPointer(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"RequiresPointer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_RequiresPointer(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"RequiresPointer"))
        {
            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::Microsoft::UI::Xaml::Controls::RequiresPointer>(arg);

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

    static PyObject* Control_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* Control_get_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsTextScaleFactorEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsTextScaleFactorEnabled"))
        {
            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.IsTextScaleFactorEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Control_get_IsFocusEngagementEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsFocusEngagementEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_IsFocusEngagementEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsFocusEngagementEnabled"))
        {
            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.IsFocusEngagementEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Control_get_IsFocusEngaged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsFocusEngaged"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_IsFocusEngaged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsFocusEngaged"))
        {
            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.IsFocusEngaged(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Control_get_IsEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_IsEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsEnabled"))
        {
            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.IsEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Control_get_HorizontalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"HorizontalContentAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_HorizontalContentAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"HorizontalContentAlignment"))
        {
            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::Microsoft::UI::Xaml::HorizontalAlignment>(arg);

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

    static PyObject* Control_get_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Foreground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Foreground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* Control_get_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* Control_get_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* Control_get_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontStretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontStretch"))
        {
            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::UI::Text::FontStretch>(arg);

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

    static PyObject* Control_get_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontSize"))
        {
            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<double>(arg);

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

    static PyObject* Control_get_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* Control_get_ElementSoundMode(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"ElementSoundMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_ElementSoundMode(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"ElementSoundMode"))
        {
            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::Microsoft::UI::Xaml::ElementSoundMode>(arg);

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

    static PyObject* Control_get_DefaultStyleResourceUri(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"DefaultStyleResourceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_DefaultStyleResourceUri(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"DefaultStyleResourceUri"))
        {
            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::Uri>(arg);

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

    static PyObject* Control_get_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"CornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"CornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

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

    static PyObject* Control_get_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"CharacterSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"CharacterSpacing"))
        {
            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<int32_t>(arg);

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

    static PyObject* Control_get_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BorderThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BorderThickness"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

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

    static PyObject* Control_get_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* Control_get_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BackgroundSizing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BackgroundSizing"))
        {
            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::Microsoft::UI::Xaml::Controls::BackgroundSizing>(arg);

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

    static PyObject* Control_get_Background(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Background"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Control_put_Background(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"Background"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

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

    static PyObject* Control_get_BackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::BackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_BackgroundSizingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BackgroundSizingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::BackgroundSizingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_BorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::BorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_BorderThicknessProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"BorderThicknessProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::BorderThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_CharacterSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"CharacterSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::CharacterSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_CornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"CornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::CornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_DefaultStyleKeyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"DefaultStyleKeyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::DefaultStyleKeyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_DefaultStyleResourceUriProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"DefaultStyleResourceUriProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::DefaultStyleResourceUriProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_ElementSoundModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"ElementSoundModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::ElementSoundModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_FontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::FontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_FontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::FontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_FontStretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontStretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::FontStretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_FontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::FontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_FontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::FontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_ForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"ForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::ForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_HorizontalContentAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"HorizontalContentAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::HorizontalContentAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_IsEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::IsEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_IsFocusEngagedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsFocusEngagedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::IsFocusEngagedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_IsFocusEngagementEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsFocusEngagementEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::IsFocusEngagementEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_IsTemplateFocusTargetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsTemplateFocusTargetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::IsTemplateFocusTargetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_IsTemplateKeyTipTargetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsTemplateKeyTipTargetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::IsTemplateKeyTipTargetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_IsTextScaleFactorEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsTextScaleFactorEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::IsTextScaleFactorEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_RequiresPointerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"RequiresPointerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::RequiresPointerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_TabNavigationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"TabNavigationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::TabNavigationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_TemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"TemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::TemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_get_VerticalContentAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Control", L"VerticalContentAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Control::VerticalContentAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Control_add_FocusDisengaged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FocusDisengaged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Control, winrt::Microsoft::UI::Xaml::Controls::FocusDisengagedEventArgs>>(arg);

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

    static PyObject* Control_remove_FocusDisengaged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FocusDisengaged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* Control_add_FocusEngaged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FocusEngaged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Control, winrt::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs>>(arg);

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

    static PyObject* Control_remove_FocusEngaged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Control", L"FocusEngaged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* Control_add_IsEnabledChanged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsEnabledChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventHandler>(arg);

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

    static PyObject* Control_remove_IsEnabledChanged(py::wrapper::Microsoft::UI::Xaml::Controls::Control* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Control", L"IsEnabledChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_Control(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Control>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Control(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Control>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Control[] = {
        { "apply_template", reinterpret_cast<PyCFunction>(Control_ApplyTemplate), METH_VARARGS, nullptr },
        { "remove_focus_engagement", reinterpret_cast<PyCFunction>(Control_RemoveFocusEngagement), METH_VARARGS, nullptr },
        { "add_focus_disengaged", reinterpret_cast<PyCFunction>(Control_add_FocusDisengaged), METH_O, nullptr },
        { "remove_focus_disengaged", reinterpret_cast<PyCFunction>(Control_remove_FocusDisengaged), METH_O, nullptr },
        { "add_focus_engaged", reinterpret_cast<PyCFunction>(Control_add_FocusEngaged), METH_O, nullptr },
        { "remove_focus_engaged", reinterpret_cast<PyCFunction>(Control_remove_FocusEngaged), METH_O, nullptr },
        { "add_is_enabled_changed", reinterpret_cast<PyCFunction>(Control_add_IsEnabledChanged), METH_O, nullptr },
        { "remove_is_enabled_changed", reinterpret_cast<PyCFunction>(Control_remove_IsEnabledChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_Control, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Control), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Control[] = {
        { "vertical_content_alignment", reinterpret_cast<getter>(Control_get_VerticalContentAlignment), reinterpret_cast<setter>(Control_put_VerticalContentAlignment), nullptr, nullptr },
        { "template", reinterpret_cast<getter>(Control_get_Template), reinterpret_cast<setter>(Control_put_Template), nullptr, nullptr },
        { "tab_navigation", reinterpret_cast<getter>(Control_get_TabNavigation), reinterpret_cast<setter>(Control_put_TabNavigation), nullptr, nullptr },
        { "requires_pointer", reinterpret_cast<getter>(Control_get_RequiresPointer), reinterpret_cast<setter>(Control_put_RequiresPointer), nullptr, nullptr },
        { "padding", reinterpret_cast<getter>(Control_get_Padding), reinterpret_cast<setter>(Control_put_Padding), nullptr, nullptr },
        { "is_text_scale_factor_enabled", reinterpret_cast<getter>(Control_get_IsTextScaleFactorEnabled), reinterpret_cast<setter>(Control_put_IsTextScaleFactorEnabled), nullptr, nullptr },
        { "is_focus_engagement_enabled", reinterpret_cast<getter>(Control_get_IsFocusEngagementEnabled), reinterpret_cast<setter>(Control_put_IsFocusEngagementEnabled), nullptr, nullptr },
        { "is_focus_engaged", reinterpret_cast<getter>(Control_get_IsFocusEngaged), reinterpret_cast<setter>(Control_put_IsFocusEngaged), nullptr, nullptr },
        { "is_enabled", reinterpret_cast<getter>(Control_get_IsEnabled), reinterpret_cast<setter>(Control_put_IsEnabled), nullptr, nullptr },
        { "horizontal_content_alignment", reinterpret_cast<getter>(Control_get_HorizontalContentAlignment), reinterpret_cast<setter>(Control_put_HorizontalContentAlignment), nullptr, nullptr },
        { "foreground", reinterpret_cast<getter>(Control_get_Foreground), reinterpret_cast<setter>(Control_put_Foreground), nullptr, nullptr },
        { "font_weight", reinterpret_cast<getter>(Control_get_FontWeight), reinterpret_cast<setter>(Control_put_FontWeight), nullptr, nullptr },
        { "font_style", reinterpret_cast<getter>(Control_get_FontStyle), reinterpret_cast<setter>(Control_put_FontStyle), nullptr, nullptr },
        { "font_stretch", reinterpret_cast<getter>(Control_get_FontStretch), reinterpret_cast<setter>(Control_put_FontStretch), nullptr, nullptr },
        { "font_size", reinterpret_cast<getter>(Control_get_FontSize), reinterpret_cast<setter>(Control_put_FontSize), nullptr, nullptr },
        { "font_family", reinterpret_cast<getter>(Control_get_FontFamily), reinterpret_cast<setter>(Control_put_FontFamily), nullptr, nullptr },
        { "element_sound_mode", reinterpret_cast<getter>(Control_get_ElementSoundMode), reinterpret_cast<setter>(Control_put_ElementSoundMode), nullptr, nullptr },
        { "default_style_resource_uri", reinterpret_cast<getter>(Control_get_DefaultStyleResourceUri), reinterpret_cast<setter>(Control_put_DefaultStyleResourceUri), nullptr, nullptr },
        { "corner_radius", reinterpret_cast<getter>(Control_get_CornerRadius), reinterpret_cast<setter>(Control_put_CornerRadius), nullptr, nullptr },
        { "character_spacing", reinterpret_cast<getter>(Control_get_CharacterSpacing), reinterpret_cast<setter>(Control_put_CharacterSpacing), nullptr, nullptr },
        { "border_thickness", reinterpret_cast<getter>(Control_get_BorderThickness), reinterpret_cast<setter>(Control_put_BorderThickness), nullptr, nullptr },
        { "border_brush", reinterpret_cast<getter>(Control_get_BorderBrush), reinterpret_cast<setter>(Control_put_BorderBrush), nullptr, nullptr },
        { "background_sizing", reinterpret_cast<getter>(Control_get_BackgroundSizing), reinterpret_cast<setter>(Control_put_BackgroundSizing), nullptr, nullptr },
        { "background", reinterpret_cast<getter>(Control_get_Background), reinterpret_cast<setter>(Control_put_Background), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Control[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Control) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Control) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Control) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Control) },
        { },
    };

    static PyType_Spec type_spec_Control =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Control",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Control),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Control
    };

    static PyGetSetDef getset_Control_Static[] = {
        { "background_property", reinterpret_cast<getter>(Control_get_BackgroundProperty), nullptr, nullptr, nullptr },
        { "background_sizing_property", reinterpret_cast<getter>(Control_get_BackgroundSizingProperty), nullptr, nullptr, nullptr },
        { "border_brush_property", reinterpret_cast<getter>(Control_get_BorderBrushProperty), nullptr, nullptr, nullptr },
        { "border_thickness_property", reinterpret_cast<getter>(Control_get_BorderThicknessProperty), nullptr, nullptr, nullptr },
        { "character_spacing_property", reinterpret_cast<getter>(Control_get_CharacterSpacingProperty), nullptr, nullptr, nullptr },
        { "corner_radius_property", reinterpret_cast<getter>(Control_get_CornerRadiusProperty), nullptr, nullptr, nullptr },
        { "default_style_key_property", reinterpret_cast<getter>(Control_get_DefaultStyleKeyProperty), nullptr, nullptr, nullptr },
        { "default_style_resource_uri_property", reinterpret_cast<getter>(Control_get_DefaultStyleResourceUriProperty), nullptr, nullptr, nullptr },
        { "element_sound_mode_property", reinterpret_cast<getter>(Control_get_ElementSoundModeProperty), nullptr, nullptr, nullptr },
        { "font_family_property", reinterpret_cast<getter>(Control_get_FontFamilyProperty), nullptr, nullptr, nullptr },
        { "font_size_property", reinterpret_cast<getter>(Control_get_FontSizeProperty), nullptr, nullptr, nullptr },
        { "font_stretch_property", reinterpret_cast<getter>(Control_get_FontStretchProperty), nullptr, nullptr, nullptr },
        { "font_style_property", reinterpret_cast<getter>(Control_get_FontStyleProperty), nullptr, nullptr, nullptr },
        { "font_weight_property", reinterpret_cast<getter>(Control_get_FontWeightProperty), nullptr, nullptr, nullptr },
        { "foreground_property", reinterpret_cast<getter>(Control_get_ForegroundProperty), nullptr, nullptr, nullptr },
        { "horizontal_content_alignment_property", reinterpret_cast<getter>(Control_get_HorizontalContentAlignmentProperty), nullptr, nullptr, nullptr },
        { "is_enabled_property", reinterpret_cast<getter>(Control_get_IsEnabledProperty), nullptr, nullptr, nullptr },
        { "is_focus_engaged_property", reinterpret_cast<getter>(Control_get_IsFocusEngagedProperty), nullptr, nullptr, nullptr },
        { "is_focus_engagement_enabled_property", reinterpret_cast<getter>(Control_get_IsFocusEngagementEnabledProperty), nullptr, nullptr, nullptr },
        { "is_template_focus_target_property", reinterpret_cast<getter>(Control_get_IsTemplateFocusTargetProperty), nullptr, nullptr, nullptr },
        { "is_template_key_tip_target_property", reinterpret_cast<getter>(Control_get_IsTemplateKeyTipTargetProperty), nullptr, nullptr, nullptr },
        { "is_text_scale_factor_enabled_property", reinterpret_cast<getter>(Control_get_IsTextScaleFactorEnabledProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(Control_get_PaddingProperty), nullptr, nullptr, nullptr },
        { "requires_pointer_property", reinterpret_cast<getter>(Control_get_RequiresPointerProperty), nullptr, nullptr, nullptr },
        { "tab_navigation_property", reinterpret_cast<getter>(Control_get_TabNavigationProperty), nullptr, nullptr, nullptr },
        { "template_property", reinterpret_cast<getter>(Control_get_TemplateProperty), nullptr, nullptr, nullptr },
        { "vertical_content_alignment_property", reinterpret_cast<getter>(Control_get_VerticalContentAlignmentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Control_Static[] = {
        { "get_is_template_focus_target", reinterpret_cast<PyCFunction>(Control_GetIsTemplateFocusTarget), METH_VARARGS, nullptr },
        { "get_is_template_key_tip_target", reinterpret_cast<PyCFunction>(Control_GetIsTemplateKeyTipTarget), METH_VARARGS, nullptr },
        { "set_is_template_focus_target", reinterpret_cast<PyCFunction>(Control_SetIsTemplateFocusTarget), METH_VARARGS, nullptr },
        { "set_is_template_key_tip_target", reinterpret_cast<PyCFunction>(Control_SetIsTemplateKeyTipTarget), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_Control_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Control_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Control_Static) },
        { }
    };

    static PyType_Spec type_spec_Control_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Control_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Control_Static
    };

    // ----- ControlTemplate class --------------------

    static PyObject* _new_ControlTemplate(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::Microsoft::UI::Xaml::Controls::ControlTemplate 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_ControlTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ControlTemplate* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ControlTemplate_get_TargetType(py::wrapper::Microsoft::UI::Xaml::Controls::ControlTemplate* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ControlTemplate", L"TargetType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int ControlTemplate_put_TargetType(py::wrapper::Microsoft::UI::Xaml::Controls::ControlTemplate* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ControlTemplate", L"TargetType"))
        {
            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::UI::Xaml::Interop::TypeName>(arg);

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

    static PyObject* _assign_array_ControlTemplate(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ControlTemplate>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ControlTemplate(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ControlTemplate>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ControlTemplate[] = {
        { "_assign_array_", _assign_array_ControlTemplate, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ControlTemplate), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ControlTemplate[] = {
        { "target_type", reinterpret_cast<getter>(ControlTemplate_get_TargetType), reinterpret_cast<setter>(ControlTemplate_put_TargetType), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ControlTemplate[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ControlTemplate) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ControlTemplate) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ControlTemplate) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ControlTemplate) },
        { },
    };

    static PyType_Spec type_spec_ControlTemplate =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ControlTemplate",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ControlTemplate),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ControlTemplate
    };

    // ----- CoreWebView2InitializedEventArgs class --------------------

    static PyObject* _new_CoreWebView2InitializedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_CoreWebView2InitializedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* CoreWebView2InitializedEventArgs_get_Exception(py::wrapper::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.CoreWebView2InitializedEventArgs", L"Exception"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_CoreWebView2InitializedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_CoreWebView2InitializedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CoreWebView2InitializedEventArgs[] = {
        { "_assign_array_", _assign_array_CoreWebView2InitializedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_CoreWebView2InitializedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CoreWebView2InitializedEventArgs[] = {
        { "exception", reinterpret_cast<getter>(CoreWebView2InitializedEventArgs_get_Exception), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_CoreWebView2InitializedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_CoreWebView2InitializedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_CoreWebView2InitializedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_CoreWebView2InitializedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_CoreWebView2InitializedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_CoreWebView2InitializedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.CoreWebView2InitializedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CoreWebView2InitializedEventArgs
    };

    // ----- DataTemplateSelector class --------------------

    static PyObject* _new_DataTemplateSelector(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::Microsoft::UI::Xaml::Controls::DataTemplateSelector 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_DataTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::DataTemplateSelector* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DataTemplateSelector_GetElement(py::wrapper::Microsoft::UI::Xaml::Controls::DataTemplateSelector* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DataTemplateSelector", L"GetElement", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::ElementFactoryGetArgs>(args, 0);

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

    static PyObject* DataTemplateSelector_RecycleElement(py::wrapper::Microsoft::UI::Xaml::Controls::DataTemplateSelector* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DataTemplateSelector", L"RecycleElement", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::ElementFactoryRecycleArgs>(args, 0);

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

    static PyObject* DataTemplateSelector_SelectTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::DataTemplateSelector* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DataTemplateSelector", L"SelectTemplate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.SelectTemplate(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DataTemplateSelector", L"SelectTemplate", 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::Microsoft::UI::Xaml::DependencyObject>(args, 1);

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

    static PyObject* _assign_array_DataTemplateSelector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DataTemplateSelector>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DataTemplateSelector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DataTemplateSelector>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DataTemplateSelector[] = {
        { "get_element", reinterpret_cast<PyCFunction>(DataTemplateSelector_GetElement), METH_VARARGS, nullptr },
        { "recycle_element", reinterpret_cast<PyCFunction>(DataTemplateSelector_RecycleElement), METH_VARARGS, nullptr },
        { "select_template", reinterpret_cast<PyCFunction>(DataTemplateSelector_SelectTemplate), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_DataTemplateSelector, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DataTemplateSelector), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DataTemplateSelector[] = {
        { }
    };

    static PyType_Slot _type_slots_DataTemplateSelector[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DataTemplateSelector) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DataTemplateSelector) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DataTemplateSelector) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DataTemplateSelector) },
        { },
    };

    static PyType_Spec type_spec_DataTemplateSelector =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DataTemplateSelector",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DataTemplateSelector),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DataTemplateSelector
    };

    // ----- DatePickedEventArgs class --------------------

    static PyObject* _new_DatePickedEventArgs(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::Microsoft::UI::Xaml::Controls::DatePickedEventArgs 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_DatePickedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DatePickedEventArgs_get_NewDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickedEventArgs", L"NewDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* DatePickedEventArgs_get_OldDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickedEventArgs", L"OldDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_DatePickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DatePickedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DatePickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DatePickedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DatePickedEventArgs[] = {
        { "_assign_array_", _assign_array_DatePickedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DatePickedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DatePickedEventArgs[] = {
        { "new_date", reinterpret_cast<getter>(DatePickedEventArgs_get_NewDate), nullptr, nullptr, nullptr },
        { "old_date", reinterpret_cast<getter>(DatePickedEventArgs_get_OldDate), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DatePickedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DatePickedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DatePickedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DatePickedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DatePickedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_DatePickedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DatePickedEventArgs
    };

    // ----- DatePicker class --------------------

    static PyObject* _new_DatePicker(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::Microsoft::UI::Xaml::Controls::DatePicker 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_DatePicker(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DatePicker_get_YearVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"YearVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_YearVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"YearVisible"))
        {
            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.YearVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_YearFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"YearFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_YearFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"YearFormat"))
        {
            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.YearFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_SelectedDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"SelectedDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_SelectedDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"SelectedDate"))
        {
            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::IReference<winrt::Windows::Foundation::DateTime>>(arg);

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

    static PyObject* DatePicker_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

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

    static PyObject* DatePicker_get_MonthVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MonthVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_MonthVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MonthVisible"))
        {
            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.MonthVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_MonthFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MonthFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_MonthFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MonthFormat"))
        {
            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.MonthFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_MinYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MinYear"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_MinYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MinYear"))
        {
            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::DateTime>(arg);

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

    static PyObject* DatePicker_get_MaxYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MaxYear"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_MaxYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MaxYear"))
        {
            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::DateTime>(arg);

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

    static PyObject* DatePicker_get_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"LightDismissOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"LightDismissOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::LightDismissOverlayMode>(arg);

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

    static PyObject* DatePicker_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* DatePicker_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_DayVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DayVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_DayVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DayVisible"))
        {
            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.DayVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_DayFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DayFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_DayFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DayFormat"))
        {
            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.DayFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_Date(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"Date"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_Date(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"Date"))
        {
            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::DateTime>(arg);

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

    static PyObject* DatePicker_get_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"CalendarIdentifier"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePicker_put_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"CalendarIdentifier"))
        {
            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.CalendarIdentifier(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePicker_get_CalendarIdentifierProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"CalendarIdentifierProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::CalendarIdentifierProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_DateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::DateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_DayFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DayFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::DayFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_DayVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DayVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::DayVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_LightDismissOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"LightDismissOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::LightDismissOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_MaxYearProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MaxYearProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::MaxYearProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_MinYearProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MinYearProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::MinYearProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_MonthFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MonthFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::MonthFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_MonthVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"MonthVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::MonthVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_SelectedDateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"SelectedDateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::SelectedDateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_YearFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"YearFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::YearFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_get_YearVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"YearVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePicker::YearVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePicker_add_DateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs>>(arg);

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

    static PyObject* DatePicker_remove_DateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"DateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* DatePicker_add_SelectedDateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"SelectedDateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::DatePicker, winrt::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs>>(arg);

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

    static PyObject* DatePicker_remove_SelectedDateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.DatePicker", L"SelectedDateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_DatePicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DatePicker>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DatePicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DatePicker>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DatePicker[] = {
        { "add_date_changed", reinterpret_cast<PyCFunction>(DatePicker_add_DateChanged), METH_O, nullptr },
        { "remove_date_changed", reinterpret_cast<PyCFunction>(DatePicker_remove_DateChanged), METH_O, nullptr },
        { "add_selected_date_changed", reinterpret_cast<PyCFunction>(DatePicker_add_SelectedDateChanged), METH_O, nullptr },
        { "remove_selected_date_changed", reinterpret_cast<PyCFunction>(DatePicker_remove_SelectedDateChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_DatePicker, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DatePicker), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DatePicker[] = {
        { "year_visible", reinterpret_cast<getter>(DatePicker_get_YearVisible), reinterpret_cast<setter>(DatePicker_put_YearVisible), nullptr, nullptr },
        { "year_format", reinterpret_cast<getter>(DatePicker_get_YearFormat), reinterpret_cast<setter>(DatePicker_put_YearFormat), nullptr, nullptr },
        { "selected_date", reinterpret_cast<getter>(DatePicker_get_SelectedDate), reinterpret_cast<setter>(DatePicker_put_SelectedDate), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(DatePicker_get_Orientation), reinterpret_cast<setter>(DatePicker_put_Orientation), nullptr, nullptr },
        { "month_visible", reinterpret_cast<getter>(DatePicker_get_MonthVisible), reinterpret_cast<setter>(DatePicker_put_MonthVisible), nullptr, nullptr },
        { "month_format", reinterpret_cast<getter>(DatePicker_get_MonthFormat), reinterpret_cast<setter>(DatePicker_put_MonthFormat), nullptr, nullptr },
        { "min_year", reinterpret_cast<getter>(DatePicker_get_MinYear), reinterpret_cast<setter>(DatePicker_put_MinYear), nullptr, nullptr },
        { "max_year", reinterpret_cast<getter>(DatePicker_get_MaxYear), reinterpret_cast<setter>(DatePicker_put_MaxYear), nullptr, nullptr },
        { "light_dismiss_overlay_mode", reinterpret_cast<getter>(DatePicker_get_LightDismissOverlayMode), reinterpret_cast<setter>(DatePicker_put_LightDismissOverlayMode), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(DatePicker_get_HeaderTemplate), reinterpret_cast<setter>(DatePicker_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(DatePicker_get_Header), reinterpret_cast<setter>(DatePicker_put_Header), nullptr, nullptr },
        { "day_visible", reinterpret_cast<getter>(DatePicker_get_DayVisible), reinterpret_cast<setter>(DatePicker_put_DayVisible), nullptr, nullptr },
        { "day_format", reinterpret_cast<getter>(DatePicker_get_DayFormat), reinterpret_cast<setter>(DatePicker_put_DayFormat), nullptr, nullptr },
        { "date", reinterpret_cast<getter>(DatePicker_get_Date), reinterpret_cast<setter>(DatePicker_put_Date), nullptr, nullptr },
        { "calendar_identifier", reinterpret_cast<getter>(DatePicker_get_CalendarIdentifier), reinterpret_cast<setter>(DatePicker_put_CalendarIdentifier), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DatePicker[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DatePicker) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DatePicker) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DatePicker) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DatePicker) },
        { },
    };

    static PyType_Spec type_spec_DatePicker =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePicker",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DatePicker),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DatePicker
    };

    static PyGetSetDef getset_DatePicker_Static[] = {
        { "calendar_identifier_property", reinterpret_cast<getter>(DatePicker_get_CalendarIdentifierProperty), nullptr, nullptr, nullptr },
        { "date_property", reinterpret_cast<getter>(DatePicker_get_DateProperty), nullptr, nullptr, nullptr },
        { "day_format_property", reinterpret_cast<getter>(DatePicker_get_DayFormatProperty), nullptr, nullptr, nullptr },
        { "day_visible_property", reinterpret_cast<getter>(DatePicker_get_DayVisibleProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(DatePicker_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(DatePicker_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "light_dismiss_overlay_mode_property", reinterpret_cast<getter>(DatePicker_get_LightDismissOverlayModeProperty), nullptr, nullptr, nullptr },
        { "max_year_property", reinterpret_cast<getter>(DatePicker_get_MaxYearProperty), nullptr, nullptr, nullptr },
        { "min_year_property", reinterpret_cast<getter>(DatePicker_get_MinYearProperty), nullptr, nullptr, nullptr },
        { "month_format_property", reinterpret_cast<getter>(DatePicker_get_MonthFormatProperty), nullptr, nullptr, nullptr },
        { "month_visible_property", reinterpret_cast<getter>(DatePicker_get_MonthVisibleProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(DatePicker_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "selected_date_property", reinterpret_cast<getter>(DatePicker_get_SelectedDateProperty), nullptr, nullptr, nullptr },
        { "year_format_property", reinterpret_cast<getter>(DatePicker_get_YearFormatProperty), nullptr, nullptr, nullptr },
        { "year_visible_property", reinterpret_cast<getter>(DatePicker_get_YearVisibleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_DatePicker_Static[] = {
        { }
    };

    static PyType_Slot type_slots_DatePicker_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_DatePicker_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_DatePicker_Static) },
        { }
    };

    static PyType_Spec type_spec_DatePicker_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePicker_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_DatePicker_Static
    };

    // ----- DatePickerFlyout class --------------------

    static PyObject* _new_DatePickerFlyout(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::Microsoft::UI::Xaml::Controls::DatePickerFlyout 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_DatePickerFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DatePickerFlyout_ShowAtAsync(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"ShowAtAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

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

    static PyObject* DatePickerFlyout_get_YearVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"YearVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_YearVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"YearVisible"))
        {
            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.YearVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyout_get_YearFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"YearFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_YearFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"YearFormat"))
        {
            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.YearFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyout_get_MonthVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MonthVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_MonthVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MonthVisible"))
        {
            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.MonthVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyout_get_MonthFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MonthFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_MonthFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MonthFormat"))
        {
            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.MonthFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyout_get_MinYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MinYear"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_MinYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MinYear"))
        {
            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::DateTime>(arg);

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

    static PyObject* DatePickerFlyout_get_MaxYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MaxYear"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_MaxYear(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MaxYear"))
        {
            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::DateTime>(arg);

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

    static PyObject* DatePickerFlyout_get_DayVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DayVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_DayVisible(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DayVisible"))
        {
            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.DayVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyout_get_DayFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DayFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_DayFormat(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DayFormat"))
        {
            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.DayFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyout_get_Date(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"Date"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_Date(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"Date"))
        {
            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::DateTime>(arg);

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

    static PyObject* DatePickerFlyout_get_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"CalendarIdentifier"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyout_put_CalendarIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"CalendarIdentifier"))
        {
            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.CalendarIdentifier(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyout_get_CalendarIdentifierProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"CalendarIdentifierProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::CalendarIdentifierProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_DateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::DateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_DayFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DayFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::DayFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_DayVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DayVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::DayVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_MaxYearProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MaxYearProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::MaxYearProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_MinYearProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MinYearProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::MinYearProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_MonthFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MonthFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::MonthFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_MonthVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"MonthVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::MonthVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_YearFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"YearFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::YearFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_get_YearVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"YearVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout::YearVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyout_add_DatePicked(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DatePicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout, winrt::Microsoft::UI::Xaml::Controls::DatePickedEventArgs>>(arg);

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

    static PyObject* DatePickerFlyout_remove_DatePicked(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyout", L"DatePicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_DatePickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DatePickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DatePickerFlyout[] = {
        { "show_at_async", reinterpret_cast<PyCFunction>(DatePickerFlyout_ShowAtAsync), METH_VARARGS, nullptr },
        { "add_date_picked", reinterpret_cast<PyCFunction>(DatePickerFlyout_add_DatePicked), METH_O, nullptr },
        { "remove_date_picked", reinterpret_cast<PyCFunction>(DatePickerFlyout_remove_DatePicked), METH_O, nullptr },
        { "_assign_array_", _assign_array_DatePickerFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DatePickerFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DatePickerFlyout[] = {
        { "year_visible", reinterpret_cast<getter>(DatePickerFlyout_get_YearVisible), reinterpret_cast<setter>(DatePickerFlyout_put_YearVisible), nullptr, nullptr },
        { "year_format", reinterpret_cast<getter>(DatePickerFlyout_get_YearFormat), reinterpret_cast<setter>(DatePickerFlyout_put_YearFormat), nullptr, nullptr },
        { "month_visible", reinterpret_cast<getter>(DatePickerFlyout_get_MonthVisible), reinterpret_cast<setter>(DatePickerFlyout_put_MonthVisible), nullptr, nullptr },
        { "month_format", reinterpret_cast<getter>(DatePickerFlyout_get_MonthFormat), reinterpret_cast<setter>(DatePickerFlyout_put_MonthFormat), nullptr, nullptr },
        { "min_year", reinterpret_cast<getter>(DatePickerFlyout_get_MinYear), reinterpret_cast<setter>(DatePickerFlyout_put_MinYear), nullptr, nullptr },
        { "max_year", reinterpret_cast<getter>(DatePickerFlyout_get_MaxYear), reinterpret_cast<setter>(DatePickerFlyout_put_MaxYear), nullptr, nullptr },
        { "day_visible", reinterpret_cast<getter>(DatePickerFlyout_get_DayVisible), reinterpret_cast<setter>(DatePickerFlyout_put_DayVisible), nullptr, nullptr },
        { "day_format", reinterpret_cast<getter>(DatePickerFlyout_get_DayFormat), reinterpret_cast<setter>(DatePickerFlyout_put_DayFormat), nullptr, nullptr },
        { "date", reinterpret_cast<getter>(DatePickerFlyout_get_Date), reinterpret_cast<setter>(DatePickerFlyout_put_Date), nullptr, nullptr },
        { "calendar_identifier", reinterpret_cast<getter>(DatePickerFlyout_get_CalendarIdentifier), reinterpret_cast<setter>(DatePickerFlyout_put_CalendarIdentifier), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DatePickerFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DatePickerFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DatePickerFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DatePickerFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DatePickerFlyout) },
        { },
    };

    static PyType_Spec type_spec_DatePickerFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DatePickerFlyout
    };

    static PyGetSetDef getset_DatePickerFlyout_Static[] = {
        { "calendar_identifier_property", reinterpret_cast<getter>(DatePickerFlyout_get_CalendarIdentifierProperty), nullptr, nullptr, nullptr },
        { "date_property", reinterpret_cast<getter>(DatePickerFlyout_get_DateProperty), nullptr, nullptr, nullptr },
        { "day_format_property", reinterpret_cast<getter>(DatePickerFlyout_get_DayFormatProperty), nullptr, nullptr, nullptr },
        { "day_visible_property", reinterpret_cast<getter>(DatePickerFlyout_get_DayVisibleProperty), nullptr, nullptr, nullptr },
        { "max_year_property", reinterpret_cast<getter>(DatePickerFlyout_get_MaxYearProperty), nullptr, nullptr, nullptr },
        { "min_year_property", reinterpret_cast<getter>(DatePickerFlyout_get_MinYearProperty), nullptr, nullptr, nullptr },
        { "month_format_property", reinterpret_cast<getter>(DatePickerFlyout_get_MonthFormatProperty), nullptr, nullptr, nullptr },
        { "month_visible_property", reinterpret_cast<getter>(DatePickerFlyout_get_MonthVisibleProperty), nullptr, nullptr, nullptr },
        { "year_format_property", reinterpret_cast<getter>(DatePickerFlyout_get_YearFormatProperty), nullptr, nullptr, nullptr },
        { "year_visible_property", reinterpret_cast<getter>(DatePickerFlyout_get_YearVisibleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_DatePickerFlyout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_DatePickerFlyout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_DatePickerFlyout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_DatePickerFlyout_Static) },
        { }
    };

    static PyType_Spec type_spec_DatePickerFlyout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerFlyout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_DatePickerFlyout_Static
    };

    // ----- DatePickerFlyoutItem class --------------------

    static PyObject* _new_DatePickerFlyoutItem(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem>::type_name);
        return nullptr;
    }

    static void _dealloc_DatePickerFlyoutItem(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DatePickerFlyoutItem_GetCustomProperty(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"GetCustomProperty", 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.GetCustomProperty(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyoutItem_GetIndexedProperty(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"GetIndexedProperty", 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::UI::Xaml::Interop::TypeName>(args, 1);

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

    static PyObject* DatePickerFlyoutItem_GetStringRepresentation(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"GetStringRepresentation", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* DatePickerFlyoutItem_get_SecondaryText(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"SecondaryText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyoutItem_put_SecondaryText(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"SecondaryText"))
        {
            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.SecondaryText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyoutItem_get_PrimaryText(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"PrimaryText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyoutItem_put_PrimaryText(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"PrimaryText"))
        {
            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.PrimaryText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyoutItem_get_Type(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"Type"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* DatePickerFlyoutItem_get_PrimaryTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"PrimaryTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem::PrimaryTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* DatePickerFlyoutItem_get_SecondaryTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem", L"SecondaryTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem::SecondaryTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_DatePickerFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DatePickerFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DatePickerFlyoutItem[] = {
        { "get_custom_property", reinterpret_cast<PyCFunction>(DatePickerFlyoutItem_GetCustomProperty), METH_VARARGS, nullptr },
        { "get_indexed_property", reinterpret_cast<PyCFunction>(DatePickerFlyoutItem_GetIndexedProperty), METH_VARARGS, nullptr },
        { "get_string_representation", reinterpret_cast<PyCFunction>(DatePickerFlyoutItem_GetStringRepresentation), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_DatePickerFlyoutItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DatePickerFlyoutItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DatePickerFlyoutItem[] = {
        { "secondary_text", reinterpret_cast<getter>(DatePickerFlyoutItem_get_SecondaryText), reinterpret_cast<setter>(DatePickerFlyoutItem_put_SecondaryText), nullptr, nullptr },
        { "primary_text", reinterpret_cast<getter>(DatePickerFlyoutItem_get_PrimaryText), reinterpret_cast<setter>(DatePickerFlyoutItem_put_PrimaryText), nullptr, nullptr },
        { "type", reinterpret_cast<getter>(DatePickerFlyoutItem_get_Type), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DatePickerFlyoutItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DatePickerFlyoutItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DatePickerFlyoutItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DatePickerFlyoutItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DatePickerFlyoutItem) },
        { },
    };

    static PyType_Spec type_spec_DatePickerFlyoutItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerFlyoutItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DatePickerFlyoutItem
    };

    static PyGetSetDef getset_DatePickerFlyoutItem_Static[] = {
        { "primary_text_property", reinterpret_cast<getter>(DatePickerFlyoutItem_get_PrimaryTextProperty), nullptr, nullptr, nullptr },
        { "secondary_text_property", reinterpret_cast<getter>(DatePickerFlyoutItem_get_SecondaryTextProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_DatePickerFlyoutItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_DatePickerFlyoutItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_DatePickerFlyoutItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_DatePickerFlyoutItem_Static) },
        { }
    };

    static PyType_Spec type_spec_DatePickerFlyoutItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerFlyoutItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_DatePickerFlyoutItem_Static
    };

    // ----- DatePickerFlyoutPresenter class --------------------

    static PyObject* _new_DatePickerFlyoutPresenter(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter>::type_name);
        return nullptr;
    }

    static void _dealloc_DatePickerFlyoutPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DatePickerFlyoutPresenter_get_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DatePickerFlyoutPresenter_put_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            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.IsDefaultShadowEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DatePickerFlyoutPresenter_get_IsDefaultShadowEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerFlyoutPresenter", L"IsDefaultShadowEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter::IsDefaultShadowEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_DatePickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DatePickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DatePickerFlyoutPresenter[] = {
        { "_assign_array_", _assign_array_DatePickerFlyoutPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DatePickerFlyoutPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DatePickerFlyoutPresenter[] = {
        { "is_default_shadow_enabled", reinterpret_cast<getter>(DatePickerFlyoutPresenter_get_IsDefaultShadowEnabled), reinterpret_cast<setter>(DatePickerFlyoutPresenter_put_IsDefaultShadowEnabled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DatePickerFlyoutPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DatePickerFlyoutPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DatePickerFlyoutPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DatePickerFlyoutPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DatePickerFlyoutPresenter) },
        { },
    };

    static PyType_Spec type_spec_DatePickerFlyoutPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerFlyoutPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerFlyoutPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DatePickerFlyoutPresenter
    };

    static PyGetSetDef getset_DatePickerFlyoutPresenter_Static[] = {
        { "is_default_shadow_enabled_property", reinterpret_cast<getter>(DatePickerFlyoutPresenter_get_IsDefaultShadowEnabledProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_DatePickerFlyoutPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_DatePickerFlyoutPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_DatePickerFlyoutPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_DatePickerFlyoutPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_DatePickerFlyoutPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerFlyoutPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_DatePickerFlyoutPresenter_Static
    };

    // ----- DatePickerSelectedValueChangedEventArgs class --------------------

    static PyObject* _new_DatePickerSelectedValueChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_DatePickerSelectedValueChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DatePickerSelectedValueChangedEventArgs_get_NewDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs", L"NewDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* DatePickerSelectedValueChangedEventArgs_get_OldDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs", L"OldDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_DatePickerSelectedValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DatePickerSelectedValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DatePickerSelectedValueChangedEventArgs[] = {
        { "_assign_array_", _assign_array_DatePickerSelectedValueChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DatePickerSelectedValueChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DatePickerSelectedValueChangedEventArgs[] = {
        { "new_date", reinterpret_cast<getter>(DatePickerSelectedValueChangedEventArgs_get_NewDate), nullptr, nullptr, nullptr },
        { "old_date", reinterpret_cast<getter>(DatePickerSelectedValueChangedEventArgs_get_OldDate), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DatePickerSelectedValueChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DatePickerSelectedValueChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DatePickerSelectedValueChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DatePickerSelectedValueChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DatePickerSelectedValueChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_DatePickerSelectedValueChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerSelectedValueChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerSelectedValueChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DatePickerSelectedValueChangedEventArgs
    };

    // ----- DatePickerValueChangedEventArgs class --------------------

    static PyObject* _new_DatePickerValueChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_DatePickerValueChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DatePickerValueChangedEventArgs_get_NewDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerValueChangedEventArgs", L"NewDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* DatePickerValueChangedEventArgs_get_OldDate(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DatePickerValueChangedEventArgs", L"OldDate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_DatePickerValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DatePickerValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DatePickerValueChangedEventArgs[] = {
        { "_assign_array_", _assign_array_DatePickerValueChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DatePickerValueChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DatePickerValueChangedEventArgs[] = {
        { "new_date", reinterpret_cast<getter>(DatePickerValueChangedEventArgs_get_NewDate), nullptr, nullptr, nullptr },
        { "old_date", reinterpret_cast<getter>(DatePickerValueChangedEventArgs_get_OldDate), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DatePickerValueChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DatePickerValueChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DatePickerValueChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DatePickerValueChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DatePickerValueChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_DatePickerValueChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DatePickerValueChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DatePickerValueChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DatePickerValueChangedEventArgs
    };

    // ----- DragItemsCompletedEventArgs class --------------------

    static PyObject* _new_DragItemsCompletedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_DragItemsCompletedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DragItemsCompletedEventArgs_get_DropResult(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DragItemsCompletedEventArgs", L"DropResult"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* DragItemsCompletedEventArgs_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DragItemsCompletedEventArgs", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_DragItemsCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DragItemsCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DragItemsCompletedEventArgs[] = {
        { "_assign_array_", _assign_array_DragItemsCompletedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DragItemsCompletedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DragItemsCompletedEventArgs[] = {
        { "drop_result", reinterpret_cast<getter>(DragItemsCompletedEventArgs_get_DropResult), nullptr, nullptr, nullptr },
        { "items", reinterpret_cast<getter>(DragItemsCompletedEventArgs_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DragItemsCompletedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DragItemsCompletedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DragItemsCompletedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DragItemsCompletedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DragItemsCompletedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_DragItemsCompletedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DragItemsCompletedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DragItemsCompletedEventArgs
    };

    // ----- DragItemsStartingEventArgs class --------------------

    static PyObject* _new_DragItemsStartingEventArgs(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::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs 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_DragItemsStartingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DragItemsStartingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DragItemsStartingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int DragItemsStartingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DragItemsStartingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* DragItemsStartingEventArgs_get_Data(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DragItemsStartingEventArgs", 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 PyObject* DragItemsStartingEventArgs_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DragItemsStartingEventArgs", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_DragItemsStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DragItemsStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DragItemsStartingEventArgs[] = {
        { "_assign_array_", _assign_array_DragItemsStartingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DragItemsStartingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DragItemsStartingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(DragItemsStartingEventArgs_get_Cancel), reinterpret_cast<setter>(DragItemsStartingEventArgs_put_Cancel), nullptr, nullptr },
        { "data", reinterpret_cast<getter>(DragItemsStartingEventArgs_get_Data), nullptr, nullptr, nullptr },
        { "items", reinterpret_cast<getter>(DragItemsStartingEventArgs_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DragItemsStartingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DragItemsStartingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DragItemsStartingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DragItemsStartingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DragItemsStartingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_DragItemsStartingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DragItemsStartingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DragItemsStartingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DragItemsStartingEventArgs
    };

    // ----- DropDownButton class --------------------

    static PyObject* _new_DropDownButton(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::Microsoft::UI::Xaml::Controls::DropDownButton 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_DropDownButton(py::wrapper::Microsoft::UI::Xaml::Controls::DropDownButton* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_DropDownButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DropDownButton>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DropDownButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DropDownButton>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DropDownButton[] = {
        { "_assign_array_", _assign_array_DropDownButton, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DropDownButton), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DropDownButton[] = {
        { }
    };

    static PyType_Slot _type_slots_DropDownButton[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DropDownButton) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DropDownButton) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DropDownButton) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DropDownButton) },
        { },
    };

    static PyType_Spec type_spec_DropDownButton =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DropDownButton",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DropDownButton),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DropDownButton
    };

    // ----- DynamicOverflowItemsChangingEventArgs class --------------------

    static PyObject* _new_DynamicOverflowItemsChangingEventArgs(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::Microsoft::UI::Xaml::Controls::DynamicOverflowItemsChangingEventArgs 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_DynamicOverflowItemsChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::DynamicOverflowItemsChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* DynamicOverflowItemsChangingEventArgs_get_Action(py::wrapper::Microsoft::UI::Xaml::Controls::DynamicOverflowItemsChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs", L"Action"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_DynamicOverflowItemsChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::DynamicOverflowItemsChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_DynamicOverflowItemsChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::DynamicOverflowItemsChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_DynamicOverflowItemsChangingEventArgs[] = {
        { "_assign_array_", _assign_array_DynamicOverflowItemsChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_DynamicOverflowItemsChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_DynamicOverflowItemsChangingEventArgs[] = {
        { "action", reinterpret_cast<getter>(DynamicOverflowItemsChangingEventArgs_get_Action), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_DynamicOverflowItemsChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_DynamicOverflowItemsChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_DynamicOverflowItemsChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_DynamicOverflowItemsChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_DynamicOverflowItemsChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_DynamicOverflowItemsChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.DynamicOverflowItemsChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::DynamicOverflowItemsChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_DynamicOverflowItemsChangingEventArgs
    };

    // ----- Expander class --------------------

    static PyObject* _new_Expander(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::Microsoft::UI::Xaml::Controls::Expander 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_Expander(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Expander_get_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"IsExpanded"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Expander_put_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"IsExpanded"))
        {
            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.IsExpanded(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Expander_get_HeaderTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"HeaderTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Expander_put_HeaderTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"HeaderTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

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

    static PyObject* Expander_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Expander_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

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

    static PyObject* Expander_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Expander_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Expander_get_ExpandDirection(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"ExpandDirection"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Expander_put_ExpandDirection(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"ExpandDirection"))
        {
            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::Microsoft::UI::Xaml::Controls::ExpandDirection>(arg);

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

    static PyObject* Expander_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* Expander_get_ExpandDirectionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"ExpandDirectionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Expander::ExpandDirectionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Expander_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Expander::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Expander_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Expander::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Expander_get_HeaderTemplateSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"HeaderTemplateSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Expander::HeaderTemplateSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Expander_get_IsExpandedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"IsExpandedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Expander::IsExpandedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Expander_add_Collapsed(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"Collapsed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Expander, winrt::Microsoft::UI::Xaml::Controls::ExpanderCollapsedEventArgs>>(arg);

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

    static PyObject* Expander_remove_Collapsed(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"Collapsed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* Expander_add_Expanding(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"Expanding"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Expander, winrt::Microsoft::UI::Xaml::Controls::ExpanderExpandingEventArgs>>(arg);

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

    static PyObject* Expander_remove_Expanding(py::wrapper::Microsoft::UI::Xaml::Controls::Expander* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Expander", L"Expanding"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_Expander(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Expander>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Expander(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Expander>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Expander[] = {
        { "add_collapsed", reinterpret_cast<PyCFunction>(Expander_add_Collapsed), METH_O, nullptr },
        { "remove_collapsed", reinterpret_cast<PyCFunction>(Expander_remove_Collapsed), METH_O, nullptr },
        { "add_expanding", reinterpret_cast<PyCFunction>(Expander_add_Expanding), METH_O, nullptr },
        { "remove_expanding", reinterpret_cast<PyCFunction>(Expander_remove_Expanding), METH_O, nullptr },
        { "_assign_array_", _assign_array_Expander, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Expander), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Expander[] = {
        { "is_expanded", reinterpret_cast<getter>(Expander_get_IsExpanded), reinterpret_cast<setter>(Expander_put_IsExpanded), nullptr, nullptr },
        { "header_template_selector", reinterpret_cast<getter>(Expander_get_HeaderTemplateSelector), reinterpret_cast<setter>(Expander_put_HeaderTemplateSelector), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(Expander_get_HeaderTemplate), reinterpret_cast<setter>(Expander_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(Expander_get_Header), reinterpret_cast<setter>(Expander_put_Header), nullptr, nullptr },
        { "expand_direction", reinterpret_cast<getter>(Expander_get_ExpandDirection), reinterpret_cast<setter>(Expander_put_ExpandDirection), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(Expander_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Expander[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Expander) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Expander) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Expander) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Expander) },
        { },
    };

    static PyType_Spec type_spec_Expander =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Expander",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Expander),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Expander
    };

    static PyGetSetDef getset_Expander_Static[] = {
        { "expand_direction_property", reinterpret_cast<getter>(Expander_get_ExpandDirectionProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(Expander_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(Expander_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "header_template_selector_property", reinterpret_cast<getter>(Expander_get_HeaderTemplateSelectorProperty), nullptr, nullptr, nullptr },
        { "is_expanded_property", reinterpret_cast<getter>(Expander_get_IsExpandedProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Expander_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Expander_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Expander_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Expander_Static) },
        { }
    };

    static PyType_Spec type_spec_Expander_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Expander_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Expander_Static
    };

    // ----- ExpanderCollapsedEventArgs class --------------------

    static PyObject* _new_ExpanderCollapsedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ExpanderCollapsedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ExpanderCollapsedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ExpanderCollapsedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderCollapsedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ExpanderCollapsedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ExpanderCollapsedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ExpanderCollapsedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ExpanderCollapsedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ExpanderCollapsedEventArgs[] = {
        { "_assign_array_", _assign_array_ExpanderCollapsedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ExpanderCollapsedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ExpanderCollapsedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_ExpanderCollapsedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ExpanderCollapsedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ExpanderCollapsedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ExpanderCollapsedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ExpanderCollapsedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ExpanderCollapsedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ExpanderCollapsedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderCollapsedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ExpanderCollapsedEventArgs
    };

    // ----- ExpanderExpandingEventArgs class --------------------

    static PyObject* _new_ExpanderExpandingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ExpanderExpandingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ExpanderExpandingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ExpanderExpandingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderExpandingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ExpanderExpandingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ExpanderExpandingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ExpanderExpandingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ExpanderExpandingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ExpanderExpandingEventArgs[] = {
        { "_assign_array_", _assign_array_ExpanderExpandingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ExpanderExpandingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ExpanderExpandingEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_ExpanderExpandingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ExpanderExpandingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ExpanderExpandingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ExpanderExpandingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ExpanderExpandingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ExpanderExpandingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ExpanderExpandingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderExpandingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ExpanderExpandingEventArgs
    };

    // ----- ExpanderTemplateSettings class --------------------

    static PyObject* _new_ExpanderTemplateSettings(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings>::type_name);
        return nullptr;
    }

    static void _dealloc_ExpanderTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ExpanderTemplateSettings_get_ContentHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ExpanderTemplateSettings", L"ContentHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* ExpanderTemplateSettings_get_NegativeContentHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ExpanderTemplateSettings", L"NegativeContentHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_ExpanderTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ExpanderTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ExpanderTemplateSettings[] = {
        { "_assign_array_", _assign_array_ExpanderTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ExpanderTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ExpanderTemplateSettings[] = {
        { "content_height", reinterpret_cast<getter>(ExpanderTemplateSettings_get_ContentHeight), nullptr, nullptr, nullptr },
        { "negative_content_height", reinterpret_cast<getter>(ExpanderTemplateSettings_get_NegativeContentHeight), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ExpanderTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ExpanderTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ExpanderTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ExpanderTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ExpanderTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_ExpanderTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ExpanderTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ExpanderTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ExpanderTemplateSettings
    };

    // ----- FlipView class --------------------

    static PyObject* _new_FlipView(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::Microsoft::UI::Xaml::Controls::FlipView 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_FlipView(py::wrapper::Microsoft::UI::Xaml::Controls::FlipView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* FlipView_get_UseTouchAnimationsForAllNavigation(py::wrapper::Microsoft::UI::Xaml::Controls::FlipView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FlipView", L"UseTouchAnimationsForAllNavigation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FlipView_put_UseTouchAnimationsForAllNavigation(py::wrapper::Microsoft::UI::Xaml::Controls::FlipView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FlipView", L"UseTouchAnimationsForAllNavigation"))
        {
            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.UseTouchAnimationsForAllNavigation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FlipView_get_UseTouchAnimationsForAllNavigationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FlipView", L"UseTouchAnimationsForAllNavigationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FlipView::UseTouchAnimationsForAllNavigationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_FlipView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::FlipView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_FlipView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::FlipView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FlipView[] = {
        { "_assign_array_", _assign_array_FlipView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FlipView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FlipView[] = {
        { "use_touch_animations_for_all_navigation", reinterpret_cast<getter>(FlipView_get_UseTouchAnimationsForAllNavigation), reinterpret_cast<setter>(FlipView_put_UseTouchAnimationsForAllNavigation), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_FlipView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_FlipView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_FlipView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_FlipView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_FlipView) },
        { },
    };

    static PyType_Spec type_spec_FlipView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FlipView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::FlipView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FlipView
    };

    static PyGetSetDef getset_FlipView_Static[] = {
        { "use_touch_animations_for_all_navigation_property", reinterpret_cast<getter>(FlipView_get_UseTouchAnimationsForAllNavigationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_FlipView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_FlipView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_FlipView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_FlipView_Static) },
        { }
    };

    static PyType_Spec type_spec_FlipView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FlipView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_FlipView_Static
    };

    // ----- FlipViewItem class --------------------

    static PyObject* _new_FlipViewItem(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::Microsoft::UI::Xaml::Controls::FlipViewItem 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_FlipViewItem(py::wrapper::Microsoft::UI::Xaml::Controls::FlipViewItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_FlipViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::FlipViewItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_FlipViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::FlipViewItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FlipViewItem[] = {
        { "_assign_array_", _assign_array_FlipViewItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FlipViewItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FlipViewItem[] = {
        { }
    };

    static PyType_Slot _type_slots_FlipViewItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_FlipViewItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_FlipViewItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_FlipViewItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_FlipViewItem) },
        { },
    };

    static PyType_Spec type_spec_FlipViewItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FlipViewItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::FlipViewItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FlipViewItem
    };

    // ----- Flyout class --------------------

    static PyObject* _new_Flyout(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::Microsoft::UI::Xaml::Controls::Flyout 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_Flyout(py::wrapper::Microsoft::UI::Xaml::Controls::Flyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Flyout_get_FlyoutPresenterStyle(py::wrapper::Microsoft::UI::Xaml::Controls::Flyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Flyout", L"FlyoutPresenterStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Flyout_put_FlyoutPresenterStyle(py::wrapper::Microsoft::UI::Xaml::Controls::Flyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Flyout", L"FlyoutPresenterStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

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

    static PyObject* Flyout_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::Flyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Flyout", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Flyout_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::Flyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Flyout", L"Content"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

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

    static PyObject* Flyout_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Flyout", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Flyout::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Flyout_get_FlyoutPresenterStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Flyout", L"FlyoutPresenterStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Flyout::FlyoutPresenterStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Flyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Flyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Flyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Flyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Flyout[] = {
        { "_assign_array_", _assign_array_Flyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Flyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Flyout[] = {
        { "flyout_presenter_style", reinterpret_cast<getter>(Flyout_get_FlyoutPresenterStyle), reinterpret_cast<setter>(Flyout_put_FlyoutPresenterStyle), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(Flyout_get_Content), reinterpret_cast<setter>(Flyout_put_Content), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Flyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Flyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Flyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Flyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Flyout) },
        { },
    };

    static PyType_Spec type_spec_Flyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Flyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Flyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Flyout
    };

    static PyGetSetDef getset_Flyout_Static[] = {
        { "content_property", reinterpret_cast<getter>(Flyout_get_ContentProperty), nullptr, nullptr, nullptr },
        { "flyout_presenter_style_property", reinterpret_cast<getter>(Flyout_get_FlyoutPresenterStyleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Flyout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Flyout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Flyout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Flyout_Static) },
        { }
    };

    static PyType_Spec type_spec_Flyout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Flyout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Flyout_Static
    };

    // ----- FlyoutPresenter class --------------------

    static PyObject* _new_FlyoutPresenter(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::Microsoft::UI::Xaml::Controls::FlyoutPresenter 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_FlyoutPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::FlyoutPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* FlyoutPresenter_get_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::FlyoutPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FlyoutPresenter_put_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::FlyoutPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            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.IsDefaultShadowEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FlyoutPresenter_get_IsDefaultShadowEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FlyoutPresenter", L"IsDefaultShadowEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FlyoutPresenter::IsDefaultShadowEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_FlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::FlyoutPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_FlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::FlyoutPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FlyoutPresenter[] = {
        { "_assign_array_", _assign_array_FlyoutPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FlyoutPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FlyoutPresenter[] = {
        { "is_default_shadow_enabled", reinterpret_cast<getter>(FlyoutPresenter_get_IsDefaultShadowEnabled), reinterpret_cast<setter>(FlyoutPresenter_put_IsDefaultShadowEnabled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_FlyoutPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_FlyoutPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_FlyoutPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_FlyoutPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_FlyoutPresenter) },
        { },
    };

    static PyType_Spec type_spec_FlyoutPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FlyoutPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::FlyoutPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FlyoutPresenter
    };

    static PyGetSetDef getset_FlyoutPresenter_Static[] = {
        { "is_default_shadow_enabled_property", reinterpret_cast<getter>(FlyoutPresenter_get_IsDefaultShadowEnabledProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_FlyoutPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_FlyoutPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_FlyoutPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_FlyoutPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_FlyoutPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FlyoutPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_FlyoutPresenter_Static
    };

    // ----- FocusDisengagedEventArgs class --------------------

    static PyObject* _new_FocusDisengagedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::FocusDisengagedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::FocusDisengagedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_FocusDisengagedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::FocusDisengagedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_FocusDisengagedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::FocusDisengagedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_FocusDisengagedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::FocusDisengagedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FocusDisengagedEventArgs[] = {
        { "_assign_array_", _assign_array_FocusDisengagedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FocusDisengagedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FocusDisengagedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_FocusDisengagedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_FocusDisengagedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_FocusDisengagedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_FocusDisengagedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_FocusDisengagedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_FocusDisengagedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FocusDisengagedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::FocusDisengagedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FocusDisengagedEventArgs
    };

    // ----- FocusEngagedEventArgs class --------------------

    static PyObject* _new_FocusEngagedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_FocusEngagedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* FocusEngagedEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FocusEngagedEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FocusEngagedEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FocusEngagedEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_FocusEngagedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_FocusEngagedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FocusEngagedEventArgs[] = {
        { "_assign_array_", _assign_array_FocusEngagedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FocusEngagedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FocusEngagedEventArgs[] = {
        { "handled", reinterpret_cast<getter>(FocusEngagedEventArgs_get_Handled), reinterpret_cast<setter>(FocusEngagedEventArgs_put_Handled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_FocusEngagedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_FocusEngagedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_FocusEngagedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_FocusEngagedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_FocusEngagedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_FocusEngagedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FocusEngagedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::FocusEngagedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FocusEngagedEventArgs
    };

    // ----- FontIcon class --------------------

    static PyObject* _new_FontIcon(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::Microsoft::UI::Xaml::Controls::FontIcon 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_FontIcon(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* FontIcon_get_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"MirroredWhenRightToLeft"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIcon_put_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"MirroredWhenRightToLeft"))
        {
            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.MirroredWhenRightToLeft(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FontIcon_get_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"IsTextScaleFactorEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIcon_put_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"IsTextScaleFactorEnabled"))
        {
            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.IsTextScaleFactorEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FontIcon_get_Glyph(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"Glyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIcon_put_Glyph(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"Glyph"))
        {
            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.Glyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FontIcon_get_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIcon_put_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* FontIcon_get_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIcon_put_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* FontIcon_get_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIcon_put_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontSize"))
        {
            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<double>(arg);

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

    static PyObject* FontIcon_get_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIcon_put_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* FontIcon_get_FontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIcon::FontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIcon_get_FontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIcon::FontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIcon_get_FontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIcon::FontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIcon_get_FontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"FontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIcon::FontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIcon_get_GlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"GlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIcon::GlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIcon_get_IsTextScaleFactorEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"IsTextScaleFactorEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIcon::IsTextScaleFactorEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIcon_get_MirroredWhenRightToLeftProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIcon", L"MirroredWhenRightToLeftProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIcon::MirroredWhenRightToLeftProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_FontIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::FontIcon>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_FontIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::FontIcon>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FontIcon[] = {
        { "_assign_array_", _assign_array_FontIcon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FontIcon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FontIcon[] = {
        { "mirrored_when_right_to_left", reinterpret_cast<getter>(FontIcon_get_MirroredWhenRightToLeft), reinterpret_cast<setter>(FontIcon_put_MirroredWhenRightToLeft), nullptr, nullptr },
        { "is_text_scale_factor_enabled", reinterpret_cast<getter>(FontIcon_get_IsTextScaleFactorEnabled), reinterpret_cast<setter>(FontIcon_put_IsTextScaleFactorEnabled), nullptr, nullptr },
        { "glyph", reinterpret_cast<getter>(FontIcon_get_Glyph), reinterpret_cast<setter>(FontIcon_put_Glyph), nullptr, nullptr },
        { "font_weight", reinterpret_cast<getter>(FontIcon_get_FontWeight), reinterpret_cast<setter>(FontIcon_put_FontWeight), nullptr, nullptr },
        { "font_style", reinterpret_cast<getter>(FontIcon_get_FontStyle), reinterpret_cast<setter>(FontIcon_put_FontStyle), nullptr, nullptr },
        { "font_size", reinterpret_cast<getter>(FontIcon_get_FontSize), reinterpret_cast<setter>(FontIcon_put_FontSize), nullptr, nullptr },
        { "font_family", reinterpret_cast<getter>(FontIcon_get_FontFamily), reinterpret_cast<setter>(FontIcon_put_FontFamily), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_FontIcon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_FontIcon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_FontIcon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_FontIcon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_FontIcon) },
        { },
    };

    static PyType_Spec type_spec_FontIcon =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FontIcon",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::FontIcon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FontIcon
    };

    static PyGetSetDef getset_FontIcon_Static[] = {
        { "font_family_property", reinterpret_cast<getter>(FontIcon_get_FontFamilyProperty), nullptr, nullptr, nullptr },
        { "font_size_property", reinterpret_cast<getter>(FontIcon_get_FontSizeProperty), nullptr, nullptr, nullptr },
        { "font_style_property", reinterpret_cast<getter>(FontIcon_get_FontStyleProperty), nullptr, nullptr, nullptr },
        { "font_weight_property", reinterpret_cast<getter>(FontIcon_get_FontWeightProperty), nullptr, nullptr, nullptr },
        { "glyph_property", reinterpret_cast<getter>(FontIcon_get_GlyphProperty), nullptr, nullptr, nullptr },
        { "is_text_scale_factor_enabled_property", reinterpret_cast<getter>(FontIcon_get_IsTextScaleFactorEnabledProperty), nullptr, nullptr, nullptr },
        { "mirrored_when_right_to_left_property", reinterpret_cast<getter>(FontIcon_get_MirroredWhenRightToLeftProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_FontIcon_Static[] = {
        { }
    };

    static PyType_Slot type_slots_FontIcon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_FontIcon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_FontIcon_Static) },
        { }
    };

    static PyType_Spec type_spec_FontIcon_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FontIcon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_FontIcon_Static
    };

    // ----- FontIconSource class --------------------

    static PyObject* _new_FontIconSource(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::Microsoft::UI::Xaml::Controls::FontIconSource 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_FontIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* FontIconSource_get_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"MirroredWhenRightToLeft"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIconSource_put_MirroredWhenRightToLeft(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"MirroredWhenRightToLeft"))
        {
            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.MirroredWhenRightToLeft(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FontIconSource_get_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"IsTextScaleFactorEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIconSource_put_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"IsTextScaleFactorEnabled"))
        {
            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.IsTextScaleFactorEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FontIconSource_get_Glyph(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"Glyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIconSource_put_Glyph(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"Glyph"))
        {
            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.Glyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* FontIconSource_get_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIconSource_put_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

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

    static PyObject* FontIconSource_get_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIconSource_put_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

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

    static PyObject* FontIconSource_get_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIconSource_put_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontSize"))
        {
            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<double>(arg);

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

    static PyObject* FontIconSource_get_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int FontIconSource_put_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

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

    static PyObject* FontIconSource_get_FontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIconSource::FontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIconSource_get_FontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIconSource::FontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIconSource_get_FontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIconSource::FontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIconSource_get_FontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"FontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIconSource::FontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIconSource_get_GlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"GlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIconSource::GlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIconSource_get_IsTextScaleFactorEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"IsTextScaleFactorEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIconSource::IsTextScaleFactorEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* FontIconSource_get_MirroredWhenRightToLeftProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.FontIconSource", L"MirroredWhenRightToLeftProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::FontIconSource::MirroredWhenRightToLeftProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_FontIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::FontIconSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_FontIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::FontIconSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_FontIconSource[] = {
        { "_assign_array_", _assign_array_FontIconSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_FontIconSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_FontIconSource[] = {
        { "mirrored_when_right_to_left", reinterpret_cast<getter>(FontIconSource_get_MirroredWhenRightToLeft), reinterpret_cast<setter>(FontIconSource_put_MirroredWhenRightToLeft), nullptr, nullptr },
        { "is_text_scale_factor_enabled", reinterpret_cast<getter>(FontIconSource_get_IsTextScaleFactorEnabled), reinterpret_cast<setter>(FontIconSource_put_IsTextScaleFactorEnabled), nullptr, nullptr },
        { "glyph", reinterpret_cast<getter>(FontIconSource_get_Glyph), reinterpret_cast<setter>(FontIconSource_put_Glyph), nullptr, nullptr },
        { "font_weight", reinterpret_cast<getter>(FontIconSource_get_FontWeight), reinterpret_cast<setter>(FontIconSource_put_FontWeight), nullptr, nullptr },
        { "font_style", reinterpret_cast<getter>(FontIconSource_get_FontStyle), reinterpret_cast<setter>(FontIconSource_put_FontStyle), nullptr, nullptr },
        { "font_size", reinterpret_cast<getter>(FontIconSource_get_FontSize), reinterpret_cast<setter>(FontIconSource_put_FontSize), nullptr, nullptr },
        { "font_family", reinterpret_cast<getter>(FontIconSource_get_FontFamily), reinterpret_cast<setter>(FontIconSource_put_FontFamily), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_FontIconSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_FontIconSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_FontIconSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_FontIconSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_FontIconSource) },
        { },
    };

    static PyType_Spec type_spec_FontIconSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FontIconSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::FontIconSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_FontIconSource
    };

    static PyGetSetDef getset_FontIconSource_Static[] = {
        { "font_family_property", reinterpret_cast<getter>(FontIconSource_get_FontFamilyProperty), nullptr, nullptr, nullptr },
        { "font_size_property", reinterpret_cast<getter>(FontIconSource_get_FontSizeProperty), nullptr, nullptr, nullptr },
        { "font_style_property", reinterpret_cast<getter>(FontIconSource_get_FontStyleProperty), nullptr, nullptr, nullptr },
        { "font_weight_property", reinterpret_cast<getter>(FontIconSource_get_FontWeightProperty), nullptr, nullptr, nullptr },
        { "glyph_property", reinterpret_cast<getter>(FontIconSource_get_GlyphProperty), nullptr, nullptr, nullptr },
        { "is_text_scale_factor_enabled_property", reinterpret_cast<getter>(FontIconSource_get_IsTextScaleFactorEnabledProperty), nullptr, nullptr, nullptr },
        { "mirrored_when_right_to_left_property", reinterpret_cast<getter>(FontIconSource_get_MirroredWhenRightToLeftProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_FontIconSource_Static[] = {
        { }
    };

    static PyType_Slot type_slots_FontIconSource_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_FontIconSource_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_FontIconSource_Static) },
        { }
    };

    static PyType_Spec type_spec_FontIconSource_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.FontIconSource_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_FontIconSource_Static
    };

    // ----- Frame class --------------------

    static PyObject* _new_Frame(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::Microsoft::UI::Xaml::Controls::Frame 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_Frame(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Frame_GetNavigationState(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"GetNavigationState", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* Frame_GoBack(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"GoBack", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.GoBack();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"GoBack", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Animation::NavigationTransitionInfo>(args, 0);

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

    static PyObject* Frame_GoForward(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"GoForward", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* Frame_Navigate(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"Navigate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::UI::Xaml::Interop::TypeName>(args, 0);

                return py::convert(self->obj.Navigate(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"Navigate", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::UI::Xaml::Interop::TypeName>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                return py::convert(self->obj.Navigate(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"Navigate", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::UI::Xaml::Interop::TypeName>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);
                auto param2 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Animation::NavigationTransitionInfo>(args, 2);

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

    static PyObject* Frame_NavigateToType(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"NavigateToType", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::UI::Xaml::Interop::TypeName>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);
                auto param2 = py::convert_to<winrt::Microsoft::UI::Xaml::Navigation::FrameNavigationOptions>(args, 2);

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

    static PyObject* Frame_SetNavigationState(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"SetNavigationState", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                self->obj.SetNavigationState(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"SetNavigationState", 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<bool>(args, 1);

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

    static PyObject* Frame_get_SourcePageType(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"SourcePageType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int Frame_put_SourcePageType(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"SourcePageType"))
        {
            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::UI::Xaml::Interop::TypeName>(arg);

            self->obj.SourcePageType(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Frame_get_IsNavigationStackEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"IsNavigationStackEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsNavigationStackEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Frame_put_IsNavigationStackEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"IsNavigationStackEnabled"))
        {
            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.IsNavigationStackEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Frame_get_CacheSize(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CacheSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CacheSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Frame_put_CacheSize(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CacheSize"))
        {
            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<int32_t>(arg);

            self->obj.CacheSize(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Frame_get_BackStack(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"BackStack"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BackStack());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_BackStackDepth(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"BackStackDepth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BackStackDepth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_CanGoBack(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CanGoBack"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanGoBack());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_CanGoForward(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CanGoForward"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanGoForward());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_CurrentSourcePageType(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CurrentSourcePageType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CurrentSourcePageType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_ForwardStack(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"ForwardStack"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ForwardStack());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_BackStackDepthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"BackStackDepthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::BackStackDepthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_BackStackProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"BackStackProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::BackStackProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_CacheSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CacheSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::CacheSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_CanGoBackProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CanGoBackProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::CanGoBackProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_CanGoForwardProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CanGoForwardProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::CanGoForwardProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_CurrentSourcePageTypeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"CurrentSourcePageTypeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::CurrentSourcePageTypeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_ForwardStackProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"ForwardStackProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::ForwardStackProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_IsNavigationStackEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"IsNavigationStackEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::IsNavigationStackEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_get_SourcePageTypeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"SourcePageTypeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Frame::SourcePageTypeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_add_Navigated(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"Navigated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Navigation::NavigatedEventHandler>(arg);

            return py::convert(self->obj.Navigated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_remove_Navigated(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"Navigated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Navigated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_add_Navigating(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"Navigating"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Navigation::NavigatingCancelEventHandler>(arg);

            return py::convert(self->obj.Navigating(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_remove_Navigating(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"Navigating"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Navigating(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_add_NavigationFailed(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"NavigationFailed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Navigation::NavigationFailedEventHandler>(arg);

            return py::convert(self->obj.NavigationFailed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_remove_NavigationFailed(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"NavigationFailed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.NavigationFailed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_add_NavigationStopped(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"NavigationStopped"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Navigation::NavigationStoppedEventHandler>(arg);

            return py::convert(self->obj.NavigationStopped(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Frame_remove_NavigationStopped(py::wrapper::Microsoft::UI::Xaml::Controls::Frame* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Frame", L"NavigationStopped"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.NavigationStopped(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Frame(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Frame>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Frame(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Frame>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Frame[] = {
        { "get_navigation_state", reinterpret_cast<PyCFunction>(Frame_GetNavigationState), METH_VARARGS, nullptr },
        { "go_back", reinterpret_cast<PyCFunction>(Frame_GoBack), METH_VARARGS, nullptr },
        { "go_forward", reinterpret_cast<PyCFunction>(Frame_GoForward), METH_VARARGS, nullptr },
        { "navigate", reinterpret_cast<PyCFunction>(Frame_Navigate), METH_VARARGS, nullptr },
        { "navigate_to_type", reinterpret_cast<PyCFunction>(Frame_NavigateToType), METH_VARARGS, nullptr },
        { "set_navigation_state", reinterpret_cast<PyCFunction>(Frame_SetNavigationState), METH_VARARGS, nullptr },
        { "add_navigated", reinterpret_cast<PyCFunction>(Frame_add_Navigated), METH_O, nullptr },
        { "remove_navigated", reinterpret_cast<PyCFunction>(Frame_remove_Navigated), METH_O, nullptr },
        { "add_navigating", reinterpret_cast<PyCFunction>(Frame_add_Navigating), METH_O, nullptr },
        { "remove_navigating", reinterpret_cast<PyCFunction>(Frame_remove_Navigating), METH_O, nullptr },
        { "add_navigation_failed", reinterpret_cast<PyCFunction>(Frame_add_NavigationFailed), METH_O, nullptr },
        { "remove_navigation_failed", reinterpret_cast<PyCFunction>(Frame_remove_NavigationFailed), METH_O, nullptr },
        { "add_navigation_stopped", reinterpret_cast<PyCFunction>(Frame_add_NavigationStopped), METH_O, nullptr },
        { "remove_navigation_stopped", reinterpret_cast<PyCFunction>(Frame_remove_NavigationStopped), METH_O, nullptr },
        { "_assign_array_", _assign_array_Frame, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Frame), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Frame[] = {
        { "source_page_type", reinterpret_cast<getter>(Frame_get_SourcePageType), reinterpret_cast<setter>(Frame_put_SourcePageType), nullptr, nullptr },
        { "is_navigation_stack_enabled", reinterpret_cast<getter>(Frame_get_IsNavigationStackEnabled), reinterpret_cast<setter>(Frame_put_IsNavigationStackEnabled), nullptr, nullptr },
        { "cache_size", reinterpret_cast<getter>(Frame_get_CacheSize), reinterpret_cast<setter>(Frame_put_CacheSize), nullptr, nullptr },
        { "back_stack", reinterpret_cast<getter>(Frame_get_BackStack), nullptr, nullptr, nullptr },
        { "back_stack_depth", reinterpret_cast<getter>(Frame_get_BackStackDepth), nullptr, nullptr, nullptr },
        { "can_go_back", reinterpret_cast<getter>(Frame_get_CanGoBack), nullptr, nullptr, nullptr },
        { "can_go_forward", reinterpret_cast<getter>(Frame_get_CanGoForward), nullptr, nullptr, nullptr },
        { "current_source_page_type", reinterpret_cast<getter>(Frame_get_CurrentSourcePageType), nullptr, nullptr, nullptr },
        { "forward_stack", reinterpret_cast<getter>(Frame_get_ForwardStack), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Frame[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Frame) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Frame) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Frame) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Frame) },
        { },
    };

    static PyType_Spec type_spec_Frame =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Frame",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Frame),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Frame
    };

    static PyGetSetDef getset_Frame_Static[] = {
        { "back_stack_depth_property", reinterpret_cast<getter>(Frame_get_BackStackDepthProperty), nullptr, nullptr, nullptr },
        { "back_stack_property", reinterpret_cast<getter>(Frame_get_BackStackProperty), nullptr, nullptr, nullptr },
        { "cache_size_property", reinterpret_cast<getter>(Frame_get_CacheSizeProperty), nullptr, nullptr, nullptr },
        { "can_go_back_property", reinterpret_cast<getter>(Frame_get_CanGoBackProperty), nullptr, nullptr, nullptr },
        { "can_go_forward_property", reinterpret_cast<getter>(Frame_get_CanGoForwardProperty), nullptr, nullptr, nullptr },
        { "current_source_page_type_property", reinterpret_cast<getter>(Frame_get_CurrentSourcePageTypeProperty), nullptr, nullptr, nullptr },
        { "forward_stack_property", reinterpret_cast<getter>(Frame_get_ForwardStackProperty), nullptr, nullptr, nullptr },
        { "is_navigation_stack_enabled_property", reinterpret_cast<getter>(Frame_get_IsNavigationStackEnabledProperty), nullptr, nullptr, nullptr },
        { "source_page_type_property", reinterpret_cast<getter>(Frame_get_SourcePageTypeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Frame_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Frame_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Frame_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Frame_Static) },
        { }
    };

    static PyType_Spec type_spec_Frame_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Frame_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Frame_Static
    };

    // ----- Grid class --------------------

    static PyObject* _new_Grid(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::Microsoft::UI::Xaml::Controls::Grid 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_Grid(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Grid_GetColumn(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"GetColumn", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::GetColumn(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_GetColumnSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"GetColumnSpan", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::GetColumnSpan(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_GetRow(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"GetRow", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::GetRow(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_GetRowSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"GetRowSpan", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::GetRowSpan(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_SetColumn(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"SetColumn", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Grid::SetColumn(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_SetColumnSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"SetColumnSpan", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Grid::SetColumnSpan(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_SetRow(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"SetRow", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Grid::SetRow(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_SetRowSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"SetRowSpan", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Grid::SetRowSpan(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Grid_get_RowSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"RowSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RowSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Grid_put_RowSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"RowSpacing"))
        {
            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<double>(arg);

            self->obj.RowSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Grid_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Padding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Grid_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.Padding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Grid_get_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"CornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CornerRadius());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Grid_put_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"CornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

            self->obj.CornerRadius(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Grid_get_ColumnSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"ColumnSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ColumnSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Grid_put_ColumnSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"ColumnSpacing"))
        {
            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<double>(arg);

            self->obj.ColumnSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Grid_get_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BorderThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BorderThickness());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Grid_put_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BorderThickness"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.BorderThickness(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Grid_get_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BorderBrush());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Grid_put_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.BorderBrush(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Grid_get_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BackgroundSizing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BackgroundSizing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Grid_put_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BackgroundSizing"))
        {
            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::Microsoft::UI::Xaml::Controls::BackgroundSizing>(arg);

            self->obj.BackgroundSizing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Grid_get_ColumnDefinitions(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"ColumnDefinitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ColumnDefinitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_RowDefinitions(py::wrapper::Microsoft::UI::Xaml::Controls::Grid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"RowDefinitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RowDefinitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_BackgroundSizingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BackgroundSizingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::BackgroundSizingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_BorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::BorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_BorderThicknessProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"BorderThicknessProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::BorderThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_ColumnProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"ColumnProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::ColumnProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_ColumnSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"ColumnSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::ColumnSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_ColumnSpanProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"ColumnSpanProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::ColumnSpanProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_CornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"CornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::CornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_RowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"RowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::RowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_RowSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"RowSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::RowSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Grid_get_RowSpanProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Grid", L"RowSpanProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Grid::RowSpanProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Grid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Grid>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Grid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Grid>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Grid[] = {
        { "_assign_array_", _assign_array_Grid, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Grid), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Grid[] = {
        { "row_spacing", reinterpret_cast<getter>(Grid_get_RowSpacing), reinterpret_cast<setter>(Grid_put_RowSpacing), nullptr, nullptr },
        { "padding", reinterpret_cast<getter>(Grid_get_Padding), reinterpret_cast<setter>(Grid_put_Padding), nullptr, nullptr },
        { "corner_radius", reinterpret_cast<getter>(Grid_get_CornerRadius), reinterpret_cast<setter>(Grid_put_CornerRadius), nullptr, nullptr },
        { "column_spacing", reinterpret_cast<getter>(Grid_get_ColumnSpacing), reinterpret_cast<setter>(Grid_put_ColumnSpacing), nullptr, nullptr },
        { "border_thickness", reinterpret_cast<getter>(Grid_get_BorderThickness), reinterpret_cast<setter>(Grid_put_BorderThickness), nullptr, nullptr },
        { "border_brush", reinterpret_cast<getter>(Grid_get_BorderBrush), reinterpret_cast<setter>(Grid_put_BorderBrush), nullptr, nullptr },
        { "background_sizing", reinterpret_cast<getter>(Grid_get_BackgroundSizing), reinterpret_cast<setter>(Grid_put_BackgroundSizing), nullptr, nullptr },
        { "column_definitions", reinterpret_cast<getter>(Grid_get_ColumnDefinitions), nullptr, nullptr, nullptr },
        { "row_definitions", reinterpret_cast<getter>(Grid_get_RowDefinitions), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Grid[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Grid) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Grid) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Grid) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Grid) },
        { },
    };

    static PyType_Spec type_spec_Grid =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Grid",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Grid),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Grid
    };

    static PyGetSetDef getset_Grid_Static[] = {
        { "background_sizing_property", reinterpret_cast<getter>(Grid_get_BackgroundSizingProperty), nullptr, nullptr, nullptr },
        { "border_brush_property", reinterpret_cast<getter>(Grid_get_BorderBrushProperty), nullptr, nullptr, nullptr },
        { "border_thickness_property", reinterpret_cast<getter>(Grid_get_BorderThicknessProperty), nullptr, nullptr, nullptr },
        { "column_property", reinterpret_cast<getter>(Grid_get_ColumnProperty), nullptr, nullptr, nullptr },
        { "column_spacing_property", reinterpret_cast<getter>(Grid_get_ColumnSpacingProperty), nullptr, nullptr, nullptr },
        { "column_span_property", reinterpret_cast<getter>(Grid_get_ColumnSpanProperty), nullptr, nullptr, nullptr },
        { "corner_radius_property", reinterpret_cast<getter>(Grid_get_CornerRadiusProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(Grid_get_PaddingProperty), nullptr, nullptr, nullptr },
        { "row_property", reinterpret_cast<getter>(Grid_get_RowProperty), nullptr, nullptr, nullptr },
        { "row_spacing_property", reinterpret_cast<getter>(Grid_get_RowSpacingProperty), nullptr, nullptr, nullptr },
        { "row_span_property", reinterpret_cast<getter>(Grid_get_RowSpanProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Grid_Static[] = {
        { "get_column", reinterpret_cast<PyCFunction>(Grid_GetColumn), METH_VARARGS, nullptr },
        { "get_column_span", reinterpret_cast<PyCFunction>(Grid_GetColumnSpan), METH_VARARGS, nullptr },
        { "get_row", reinterpret_cast<PyCFunction>(Grid_GetRow), METH_VARARGS, nullptr },
        { "get_row_span", reinterpret_cast<PyCFunction>(Grid_GetRowSpan), METH_VARARGS, nullptr },
        { "set_column", reinterpret_cast<PyCFunction>(Grid_SetColumn), METH_VARARGS, nullptr },
        { "set_column_span", reinterpret_cast<PyCFunction>(Grid_SetColumnSpan), METH_VARARGS, nullptr },
        { "set_row", reinterpret_cast<PyCFunction>(Grid_SetRow), METH_VARARGS, nullptr },
        { "set_row_span", reinterpret_cast<PyCFunction>(Grid_SetRowSpan), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_Grid_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Grid_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Grid_Static) },
        { }
    };

    static PyType_Spec type_spec_Grid_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Grid_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Grid_Static
    };

    // ----- GridView class --------------------

    static PyObject* _new_GridView(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::Microsoft::UI::Xaml::Controls::GridView 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_GridView(py::wrapper::Microsoft::UI::Xaml::Controls::GridView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_GridView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::GridView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GridView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::GridView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GridView[] = {
        { "_assign_array_", _assign_array_GridView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GridView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GridView[] = {
        { }
    };

    static PyType_Slot _type_slots_GridView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GridView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GridView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GridView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GridView) },
        { },
    };

    static PyType_Spec type_spec_GridView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.GridView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::GridView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GridView
    };

    // ----- GridViewHeaderItem class --------------------

    static PyObject* _new_GridViewHeaderItem(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::Microsoft::UI::Xaml::Controls::GridViewHeaderItem 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_GridViewHeaderItem(py::wrapper::Microsoft::UI::Xaml::Controls::GridViewHeaderItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_GridViewHeaderItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::GridViewHeaderItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GridViewHeaderItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::GridViewHeaderItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GridViewHeaderItem[] = {
        { "_assign_array_", _assign_array_GridViewHeaderItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GridViewHeaderItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GridViewHeaderItem[] = {
        { }
    };

    static PyType_Slot _type_slots_GridViewHeaderItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GridViewHeaderItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GridViewHeaderItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GridViewHeaderItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GridViewHeaderItem) },
        { },
    };

    static PyType_Spec type_spec_GridViewHeaderItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.GridViewHeaderItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::GridViewHeaderItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GridViewHeaderItem
    };

    // ----- GridViewItem class --------------------

    static PyObject* _new_GridViewItem(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::Microsoft::UI::Xaml::Controls::GridViewItem 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_GridViewItem(py::wrapper::Microsoft::UI::Xaml::Controls::GridViewItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* GridViewItem_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::GridViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GridViewItem", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_GridViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::GridViewItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GridViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::GridViewItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GridViewItem[] = {
        { "_assign_array_", _assign_array_GridViewItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GridViewItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GridViewItem[] = {
        { "template_settings", reinterpret_cast<getter>(GridViewItem_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GridViewItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GridViewItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GridViewItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GridViewItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GridViewItem) },
        { },
    };

    static PyType_Spec type_spec_GridViewItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.GridViewItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::GridViewItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GridViewItem
    };

    // ----- GroupItem class --------------------

    static PyObject* _new_GroupItem(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::Microsoft::UI::Xaml::Controls::GroupItem 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_GroupItem(py::wrapper::Microsoft::UI::Xaml::Controls::GroupItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_GroupItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::GroupItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GroupItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::GroupItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GroupItem[] = {
        { "_assign_array_", _assign_array_GroupItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GroupItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GroupItem[] = {
        { }
    };

    static PyType_Slot _type_slots_GroupItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GroupItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GroupItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GroupItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GroupItem) },
        { },
    };

    static PyType_Spec type_spec_GroupItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.GroupItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::GroupItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GroupItem
    };

    // ----- GroupStyle class --------------------

    static PyObject* _new_GroupStyle(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::Microsoft::UI::Xaml::Controls::GroupStyle 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_GroupStyle(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* GroupStyle_get_Panel(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"Panel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Panel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int GroupStyle_put_Panel(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"Panel"))
        {
            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::Microsoft::UI::Xaml::Controls::ItemsPanelTemplate>(arg);

            self->obj.Panel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* GroupStyle_get_HidesIfEmpty(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HidesIfEmpty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HidesIfEmpty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int GroupStyle_put_HidesIfEmpty(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HidesIfEmpty"))
        {
            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.HidesIfEmpty(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* GroupStyle_get_HeaderTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HeaderTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplateSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int GroupStyle_put_HeaderTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HeaderTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

            self->obj.HeaderTemplateSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* GroupStyle_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int GroupStyle_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* GroupStyle_get_HeaderContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HeaderContainerStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderContainerStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int GroupStyle_put_HeaderContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"HeaderContainerStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.HeaderContainerStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* GroupStyle_get_ContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"ContainerStyleSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContainerStyleSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int GroupStyle_put_ContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"ContainerStyleSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::StyleSelector>(arg);

            self->obj.ContainerStyleSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* GroupStyle_get_ContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"ContainerStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContainerStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int GroupStyle_put_ContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"ContainerStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.ContainerStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* GroupStyle_add_PropertyChanged(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"PropertyChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Data::PropertyChangedEventHandler>(arg);

            return py::convert(self->obj.PropertyChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* GroupStyle_remove_PropertyChanged(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.GroupStyle", L"PropertyChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PropertyChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_GroupStyle(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::GroupStyle>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GroupStyle(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::GroupStyle>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GroupStyle[] = {
        { "add_property_changed", reinterpret_cast<PyCFunction>(GroupStyle_add_PropertyChanged), METH_O, nullptr },
        { "remove_property_changed", reinterpret_cast<PyCFunction>(GroupStyle_remove_PropertyChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_GroupStyle, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GroupStyle), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GroupStyle[] = {
        { "panel", reinterpret_cast<getter>(GroupStyle_get_Panel), reinterpret_cast<setter>(GroupStyle_put_Panel), nullptr, nullptr },
        { "hides_if_empty", reinterpret_cast<getter>(GroupStyle_get_HidesIfEmpty), reinterpret_cast<setter>(GroupStyle_put_HidesIfEmpty), nullptr, nullptr },
        { "header_template_selector", reinterpret_cast<getter>(GroupStyle_get_HeaderTemplateSelector), reinterpret_cast<setter>(GroupStyle_put_HeaderTemplateSelector), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(GroupStyle_get_HeaderTemplate), reinterpret_cast<setter>(GroupStyle_put_HeaderTemplate), nullptr, nullptr },
        { "header_container_style", reinterpret_cast<getter>(GroupStyle_get_HeaderContainerStyle), reinterpret_cast<setter>(GroupStyle_put_HeaderContainerStyle), nullptr, nullptr },
        { "container_style_selector", reinterpret_cast<getter>(GroupStyle_get_ContainerStyleSelector), reinterpret_cast<setter>(GroupStyle_put_ContainerStyleSelector), nullptr, nullptr },
        { "container_style", reinterpret_cast<getter>(GroupStyle_get_ContainerStyle), reinterpret_cast<setter>(GroupStyle_put_ContainerStyle), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_GroupStyle[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GroupStyle) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GroupStyle) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GroupStyle) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GroupStyle) },
        { },
    };

    static PyType_Spec type_spec_GroupStyle =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.GroupStyle",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyle),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GroupStyle
    };

    // ----- GroupStyleSelector class --------------------

    static PyObject* _new_GroupStyleSelector(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::Microsoft::UI::Xaml::Controls::GroupStyleSelector 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_GroupStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyleSelector* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* GroupStyleSelector_SelectGroupStyle(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyleSelector* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.GroupStyleSelector", L"SelectGroupStyle", 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<uint32_t>(args, 1);

                return py::convert(self->obj.SelectGroupStyle(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_GroupStyleSelector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::GroupStyleSelector>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_GroupStyleSelector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::GroupStyleSelector>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_GroupStyleSelector[] = {
        { "select_group_style", reinterpret_cast<PyCFunction>(GroupStyleSelector_SelectGroupStyle), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_GroupStyleSelector, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_GroupStyleSelector), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_GroupStyleSelector[] = {
        { }
    };

    static PyType_Slot _type_slots_GroupStyleSelector[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_GroupStyleSelector) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_GroupStyleSelector) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_GroupStyleSelector) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_GroupStyleSelector) },
        { },
    };

    static PyType_Spec type_spec_GroupStyleSelector =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.GroupStyleSelector",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::GroupStyleSelector),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_GroupStyleSelector
    };

    // ----- HasValidationErrorsChangedEventArgs class --------------------

    static PyObject* _new_HasValidationErrorsChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::HasValidationErrorsChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::HasValidationErrorsChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_HasValidationErrorsChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::HasValidationErrorsChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* HasValidationErrorsChangedEventArgs_get_NewValue(py::wrapper::Microsoft::UI::Xaml::Controls::HasValidationErrorsChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HasValidationErrorsChangedEventArgs", L"NewValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_HasValidationErrorsChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::HasValidationErrorsChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HasValidationErrorsChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::HasValidationErrorsChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HasValidationErrorsChangedEventArgs[] = {
        { "_assign_array_", _assign_array_HasValidationErrorsChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HasValidationErrorsChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HasValidationErrorsChangedEventArgs[] = {
        { "new_value", reinterpret_cast<getter>(HasValidationErrorsChangedEventArgs_get_NewValue), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HasValidationErrorsChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HasValidationErrorsChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HasValidationErrorsChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HasValidationErrorsChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HasValidationErrorsChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_HasValidationErrorsChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.HasValidationErrorsChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::HasValidationErrorsChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HasValidationErrorsChangedEventArgs
    };

    // ----- Hub class --------------------

    static PyObject* _new_Hub(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::Microsoft::UI::Xaml::Controls::Hub 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_Hub(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Hub_CompleteViewChange(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"CompleteViewChange", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CompleteViewChange();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_CompleteViewChangeFrom(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"CompleteViewChangeFrom", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.CompleteViewChangeFrom(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_CompleteViewChangeTo(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"CompleteViewChangeTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.CompleteViewChangeTo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_InitializeViewChange(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"InitializeViewChange", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.InitializeViewChange();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_MakeVisible(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"MakeVisible", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);

                self->obj.MakeVisible(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_ScrollToSection(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"ScrollToSection", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::HubSection>(args, 0);

                self->obj.ScrollToSection(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_StartViewChangeFrom(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"StartViewChangeFrom", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.StartViewChangeFrom(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_StartViewChangeTo(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"StartViewChangeTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.StartViewChangeTo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Hub_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Hub_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Hub_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Hub_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Hub_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Hub_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Hub_get_DefaultSectionIndex(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"DefaultSectionIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DefaultSectionIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Hub_put_DefaultSectionIndex(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"DefaultSectionIndex"))
        {
            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<int32_t>(arg);

            self->obj.DefaultSectionIndex(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Hub_get_SectionHeaders(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SectionHeaders"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SectionHeaders());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_Sections(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"Sections"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Sections());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_SectionsInView(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SectionsInView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SectionsInView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_SemanticZoomOwner(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SemanticZoomOwner"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SemanticZoomOwner());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Hub_put_SemanticZoomOwner(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SemanticZoomOwner"))
        {
            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::Microsoft::UI::Xaml::Controls::SemanticZoom>(arg);

            self->obj.SemanticZoomOwner(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Hub_get_IsZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"IsZoomedInView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomedInView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Hub_put_IsZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"IsZoomedInView"))
        {
            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.IsZoomedInView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Hub_get_IsActiveView(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"IsActiveView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsActiveView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Hub_put_IsActiveView(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"IsActiveView"))
        {
            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.IsActiveView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Hub_get_DefaultSectionIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"DefaultSectionIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Hub::DefaultSectionIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Hub::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Hub::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_IsActiveViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"IsActiveViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Hub::IsActiveViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_IsZoomedInViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"IsZoomedInViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Hub::IsZoomedInViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Hub::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_get_SemanticZoomOwnerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SemanticZoomOwnerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Hub::SemanticZoomOwnerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_add_SectionHeaderClick(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SectionHeaderClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::HubSectionHeaderClickEventHandler>(arg);

            return py::convert(self->obj.SectionHeaderClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_remove_SectionHeaderClick(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SectionHeaderClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SectionHeaderClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_add_SectionsInViewChanged(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SectionsInViewChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventHandler>(arg);

            return py::convert(self->obj.SectionsInViewChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Hub_remove_SectionsInViewChanged(py::wrapper::Microsoft::UI::Xaml::Controls::Hub* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Hub", L"SectionsInViewChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SectionsInViewChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Hub(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Hub>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Hub(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Hub>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Hub[] = {
        { "complete_view_change", reinterpret_cast<PyCFunction>(Hub_CompleteViewChange), METH_VARARGS, nullptr },
        { "complete_view_change_from", reinterpret_cast<PyCFunction>(Hub_CompleteViewChangeFrom), METH_VARARGS, nullptr },
        { "complete_view_change_to", reinterpret_cast<PyCFunction>(Hub_CompleteViewChangeTo), METH_VARARGS, nullptr },
        { "initialize_view_change", reinterpret_cast<PyCFunction>(Hub_InitializeViewChange), METH_VARARGS, nullptr },
        { "make_visible", reinterpret_cast<PyCFunction>(Hub_MakeVisible), METH_VARARGS, nullptr },
        { "scroll_to_section", reinterpret_cast<PyCFunction>(Hub_ScrollToSection), METH_VARARGS, nullptr },
        { "start_view_change_from", reinterpret_cast<PyCFunction>(Hub_StartViewChangeFrom), METH_VARARGS, nullptr },
        { "start_view_change_to", reinterpret_cast<PyCFunction>(Hub_StartViewChangeTo), METH_VARARGS, nullptr },
        { "add_section_header_click", reinterpret_cast<PyCFunction>(Hub_add_SectionHeaderClick), METH_O, nullptr },
        { "remove_section_header_click", reinterpret_cast<PyCFunction>(Hub_remove_SectionHeaderClick), METH_O, nullptr },
        { "add_sections_in_view_changed", reinterpret_cast<PyCFunction>(Hub_add_SectionsInViewChanged), METH_O, nullptr },
        { "remove_sections_in_view_changed", reinterpret_cast<PyCFunction>(Hub_remove_SectionsInViewChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_Hub, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Hub), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Hub[] = {
        { "orientation", reinterpret_cast<getter>(Hub_get_Orientation), reinterpret_cast<setter>(Hub_put_Orientation), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(Hub_get_HeaderTemplate), reinterpret_cast<setter>(Hub_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(Hub_get_Header), reinterpret_cast<setter>(Hub_put_Header), nullptr, nullptr },
        { "default_section_index", reinterpret_cast<getter>(Hub_get_DefaultSectionIndex), reinterpret_cast<setter>(Hub_put_DefaultSectionIndex), nullptr, nullptr },
        { "section_headers", reinterpret_cast<getter>(Hub_get_SectionHeaders), nullptr, nullptr, nullptr },
        { "sections", reinterpret_cast<getter>(Hub_get_Sections), nullptr, nullptr, nullptr },
        { "sections_in_view", reinterpret_cast<getter>(Hub_get_SectionsInView), nullptr, nullptr, nullptr },
        { "semantic_zoom_owner", reinterpret_cast<getter>(Hub_get_SemanticZoomOwner), reinterpret_cast<setter>(Hub_put_SemanticZoomOwner), nullptr, nullptr },
        { "is_zoomed_in_view", reinterpret_cast<getter>(Hub_get_IsZoomedInView), reinterpret_cast<setter>(Hub_put_IsZoomedInView), nullptr, nullptr },
        { "is_active_view", reinterpret_cast<getter>(Hub_get_IsActiveView), reinterpret_cast<setter>(Hub_put_IsActiveView), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Hub[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Hub) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Hub) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Hub) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Hub) },
        { },
    };

    static PyType_Spec type_spec_Hub =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Hub",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Hub),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Hub
    };

    static PyGetSetDef getset_Hub_Static[] = {
        { "default_section_index_property", reinterpret_cast<getter>(Hub_get_DefaultSectionIndexProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(Hub_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(Hub_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_active_view_property", reinterpret_cast<getter>(Hub_get_IsActiveViewProperty), nullptr, nullptr, nullptr },
        { "is_zoomed_in_view_property", reinterpret_cast<getter>(Hub_get_IsZoomedInViewProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(Hub_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "semantic_zoom_owner_property", reinterpret_cast<getter>(Hub_get_SemanticZoomOwnerProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Hub_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Hub_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Hub_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Hub_Static) },
        { }
    };

    static PyType_Spec type_spec_Hub_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Hub_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Hub_Static
    };

    // ----- HubSection class --------------------

    static PyObject* _new_HubSection(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::Microsoft::UI::Xaml::Controls::HubSection 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_HubSection(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* HubSection_get_IsHeaderInteractive(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"IsHeaderInteractive"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsHeaderInteractive());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HubSection_put_IsHeaderInteractive(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"IsHeaderInteractive"))
        {
            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.IsHeaderInteractive(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HubSection_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HubSection_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HubSection_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HubSection_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HubSection_get_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"ContentTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HubSection_put_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"ContentTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.ContentTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HubSection_get_ContentTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"ContentTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::HubSection::ContentTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HubSection_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::HubSection::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HubSection_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::HubSection::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* HubSection_get_IsHeaderInteractiveProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSection", L"IsHeaderInteractiveProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::HubSection::IsHeaderInteractiveProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_HubSection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::HubSection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HubSection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::HubSection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HubSection[] = {
        { "_assign_array_", _assign_array_HubSection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HubSection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HubSection[] = {
        { "is_header_interactive", reinterpret_cast<getter>(HubSection_get_IsHeaderInteractive), reinterpret_cast<setter>(HubSection_put_IsHeaderInteractive), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(HubSection_get_HeaderTemplate), reinterpret_cast<setter>(HubSection_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(HubSection_get_Header), reinterpret_cast<setter>(HubSection_put_Header), nullptr, nullptr },
        { "content_template", reinterpret_cast<getter>(HubSection_get_ContentTemplate), reinterpret_cast<setter>(HubSection_put_ContentTemplate), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HubSection[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HubSection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HubSection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HubSection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HubSection) },
        { },
    };

    static PyType_Spec type_spec_HubSection =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.HubSection",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::HubSection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HubSection
    };

    static PyGetSetDef getset_HubSection_Static[] = {
        { "content_template_property", reinterpret_cast<getter>(HubSection_get_ContentTemplateProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(HubSection_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(HubSection_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_header_interactive_property", reinterpret_cast<getter>(HubSection_get_IsHeaderInteractiveProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_HubSection_Static[] = {
        { }
    };

    static PyType_Slot type_slots_HubSection_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_HubSection_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_HubSection_Static) },
        { }
    };

    static PyType_Spec type_spec_HubSection_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.HubSection_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_HubSection_Static
    };

    // ----- HubSectionCollection class --------------------

    static PyObject* _new_HubSectionCollection(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::HubSectionCollection>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::HubSectionCollection>::type_name);
        return nullptr;
    }

    static void _dealloc_HubSectionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* HubSectionCollection_Append(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"Append", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::HubSection>(args, 0);

                self->obj.Append(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_Clear(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"Clear", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Clear();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_First(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", 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* HubSectionCollection_GetAt(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", 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* HubSectionCollection_GetMany(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", 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::Microsoft::UI::Xaml::Controls::HubSection, 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* HubSectionCollection_GetView(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"GetView", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetView());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_IndexOf(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::HubSection>(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* HubSectionCollection_InsertAt(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"InsertAt", 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::Microsoft::UI::Xaml::Controls::HubSection>(args, 1);

                self->obj.InsertAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_RemoveAt(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"RemoveAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);

                self->obj.RemoveAt(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_RemoveAtEnd(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"RemoveAtEnd", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RemoveAtEnd();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_ReplaceAll(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"ReplaceAll", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<winrt::Microsoft::UI::Xaml::Controls::HubSection, false>>(args, 0);

                self->obj.ReplaceAll(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_SetAt(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", L"SetAt", 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::Microsoft::UI::Xaml::Controls::HubSection>(args, 1);

                self->obj.SetAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* HubSectionCollection_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSectionCollection", 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_HubSectionCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::HubSectionCollection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HubSectionCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::HubSectionCollection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_HubSectionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_HubSectionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_HubSectionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* 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_HubSectionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* 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_HubSectionCollection(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::Microsoft::UI::Xaml::Controls::HubSection> items(static_cast<uint32_t>(length), empty_instance<winrt::Microsoft::UI::Xaml::Controls::HubSection>::get());

            auto count = self->obj.GetMany(static_cast<uint32_t>(start), items);

            if (count != static_cast<uint32_t>(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 int _seq_assign_HubSectionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection* self, Py_ssize_t i, PyObject* value) noexcept
    {
        try
        {
            if (value == nullptr) { self->obj.RemoveAt(static_cast<uint32_t>(i)); }
            else { self->obj.SetAt(static_cast<uint32_t>(i), py::convert_to<winrt::Microsoft::UI::Xaml::Controls::HubSection>(value)); }
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyMethodDef _methods_HubSectionCollection[] = {
        { "append", reinterpret_cast<PyCFunction>(HubSectionCollection_Append), METH_VARARGS, nullptr },
        { "clear", reinterpret_cast<PyCFunction>(HubSectionCollection_Clear), METH_VARARGS, nullptr },
        { "first", reinterpret_cast<PyCFunction>(HubSectionCollection_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(HubSectionCollection_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(HubSectionCollection_GetMany), METH_VARARGS, nullptr },
        { "get_view", reinterpret_cast<PyCFunction>(HubSectionCollection_GetView), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(HubSectionCollection_IndexOf), METH_VARARGS, nullptr },
        { "insert_at", reinterpret_cast<PyCFunction>(HubSectionCollection_InsertAt), METH_VARARGS, nullptr },
        { "remove_at", reinterpret_cast<PyCFunction>(HubSectionCollection_RemoveAt), METH_VARARGS, nullptr },
        { "remove_at_end", reinterpret_cast<PyCFunction>(HubSectionCollection_RemoveAtEnd), METH_VARARGS, nullptr },
        { "replace_all", reinterpret_cast<PyCFunction>(HubSectionCollection_ReplaceAll), METH_VARARGS, nullptr },
        { "set_at", reinterpret_cast<PyCFunction>(HubSectionCollection_SetAt), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_HubSectionCollection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HubSectionCollection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HubSectionCollection[] = {
        { "size", reinterpret_cast<getter>(HubSectionCollection_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HubSectionCollection[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HubSectionCollection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HubSectionCollection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HubSectionCollection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HubSectionCollection) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_HubSectionCollection) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_HubSectionCollection) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_HubSectionCollection) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_HubSectionCollection) },
        { Py_sq_ass_item, reinterpret_cast<void*>(_seq_assign_HubSectionCollection) },
        { },
    };

    static PyType_Spec type_spec_HubSectionCollection =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.HubSectionCollection",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionCollection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HubSectionCollection
    };

    // ----- HubSectionHeaderClickEventArgs class --------------------

    static PyObject* _new_HubSectionHeaderClickEventArgs(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::Microsoft::UI::Xaml::Controls::HubSectionHeaderClickEventArgs 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_HubSectionHeaderClickEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionHeaderClickEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* HubSectionHeaderClickEventArgs_get_Section(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionHeaderClickEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HubSectionHeaderClickEventArgs", L"Section"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Section());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_HubSectionHeaderClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::HubSectionHeaderClickEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HubSectionHeaderClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::HubSectionHeaderClickEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HubSectionHeaderClickEventArgs[] = {
        { "_assign_array_", _assign_array_HubSectionHeaderClickEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HubSectionHeaderClickEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HubSectionHeaderClickEventArgs[] = {
        { "section", reinterpret_cast<getter>(HubSectionHeaderClickEventArgs_get_Section), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HubSectionHeaderClickEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HubSectionHeaderClickEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HubSectionHeaderClickEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HubSectionHeaderClickEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HubSectionHeaderClickEventArgs) },
        { },
    };

    static PyType_Spec type_spec_HubSectionHeaderClickEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.HubSectionHeaderClickEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::HubSectionHeaderClickEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HubSectionHeaderClickEventArgs
    };

    // ----- HyperlinkButton class --------------------

    static PyObject* _new_HyperlinkButton(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::Microsoft::UI::Xaml::Controls::HyperlinkButton 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_HyperlinkButton(py::wrapper::Microsoft::UI::Xaml::Controls::HyperlinkButton* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* HyperlinkButton_get_NavigateUri(py::wrapper::Microsoft::UI::Xaml::Controls::HyperlinkButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HyperlinkButton", L"NavigateUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NavigateUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int HyperlinkButton_put_NavigateUri(py::wrapper::Microsoft::UI::Xaml::Controls::HyperlinkButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HyperlinkButton", L"NavigateUri"))
        {
            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::Uri>(arg);

            self->obj.NavigateUri(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* HyperlinkButton_get_NavigateUriProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.HyperlinkButton", L"NavigateUriProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::HyperlinkButton::NavigateUriProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_HyperlinkButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::HyperlinkButton>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_HyperlinkButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::HyperlinkButton>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_HyperlinkButton[] = {
        { "_assign_array_", _assign_array_HyperlinkButton, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_HyperlinkButton), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HyperlinkButton[] = {
        { "navigate_uri", reinterpret_cast<getter>(HyperlinkButton_get_NavigateUri), reinterpret_cast<setter>(HyperlinkButton_put_NavigateUri), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HyperlinkButton[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_HyperlinkButton) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_HyperlinkButton) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_HyperlinkButton) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_HyperlinkButton) },
        { },
    };

    static PyType_Spec type_spec_HyperlinkButton =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.HyperlinkButton",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::HyperlinkButton),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HyperlinkButton
    };

    static PyGetSetDef getset_HyperlinkButton_Static[] = {
        { "navigate_uri_property", reinterpret_cast<getter>(HyperlinkButton_get_NavigateUriProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_HyperlinkButton_Static[] = {
        { }
    };

    static PyType_Slot type_slots_HyperlinkButton_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_HyperlinkButton_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_HyperlinkButton_Static) },
        { }
    };

    static PyType_Spec type_spec_HyperlinkButton_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.HyperlinkButton_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_HyperlinkButton_Static
    };

    // ----- IconElement class --------------------

    static PyObject* _new_IconElement(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IconElement>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IconElement>::type_name);
        return nullptr;
    }

    static void _dealloc_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::IconElement* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IconElement_get_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::IconElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconElement", L"Foreground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Foreground());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IconElement_put_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::IconElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconElement", L"Foreground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Foreground(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IconElement_get_ForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconElement", L"ForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::IconElement::ForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_IconElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IconElement>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IconElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IconElement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IconElement[] = {
        { "_assign_array_", _assign_array_IconElement, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IconElement), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IconElement[] = {
        { "foreground", reinterpret_cast<getter>(IconElement_get_Foreground), reinterpret_cast<setter>(IconElement_put_Foreground), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IconElement[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IconElement) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IconElement) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IconElement) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IconElement) },
        { },
    };

    static PyType_Spec type_spec_IconElement =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IconElement",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IconElement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IconElement
    };

    static PyGetSetDef getset_IconElement_Static[] = {
        { "foreground_property", reinterpret_cast<getter>(IconElement_get_ForegroundProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_IconElement_Static[] = {
        { }
    };

    static PyType_Slot type_slots_IconElement_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_IconElement_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_IconElement_Static) },
        { }
    };

    static PyType_Spec type_spec_IconElement_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IconElement_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_IconElement_Static
    };

    // ----- IconSource class --------------------

    static PyObject* _new_IconSource(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IconSource>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IconSource>::type_name);
        return nullptr;
    }

    static void _dealloc_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::IconSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IconSource_CreateIconElement(py::wrapper::Microsoft::UI::Xaml::Controls::IconSource* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IconSource", L"CreateIconElement", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.CreateIconElement());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IconSource_get_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::IconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconSource", L"Foreground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Foreground());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IconSource_put_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::IconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconSource", L"Foreground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Foreground(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IconSource_get_ForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconSource", L"ForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::IconSource::ForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_IconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IconSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IconSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IconSource[] = {
        { "create_icon_element", reinterpret_cast<PyCFunction>(IconSource_CreateIconElement), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IconSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IconSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IconSource[] = {
        { "foreground", reinterpret_cast<getter>(IconSource_get_Foreground), reinterpret_cast<setter>(IconSource_put_Foreground), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IconSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IconSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IconSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IconSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IconSource) },
        { },
    };

    static PyType_Spec type_spec_IconSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IconSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IconSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IconSource
    };

    static PyGetSetDef getset_IconSource_Static[] = {
        { "foreground_property", reinterpret_cast<getter>(IconSource_get_ForegroundProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_IconSource_Static[] = {
        { }
    };

    static PyType_Slot type_slots_IconSource_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_IconSource_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_IconSource_Static) },
        { }
    };

    static PyType_Spec type_spec_IconSource_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IconSource_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_IconSource_Static
    };

    // ----- IconSourceElement class --------------------

    static PyObject* _new_IconSourceElement(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::Microsoft::UI::Xaml::Controls::IconSourceElement 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_IconSourceElement(py::wrapper::Microsoft::UI::Xaml::Controls::IconSourceElement* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IconSourceElement_get_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::IconSourceElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconSourceElement", L"IconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IconSourceElement_put_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::IconSourceElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconSourceElement", L"IconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

            self->obj.IconSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IconSourceElement_get_IconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IconSourceElement", L"IconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::IconSourceElement::IconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_IconSourceElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IconSourceElement>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IconSourceElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IconSourceElement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IconSourceElement[] = {
        { "_assign_array_", _assign_array_IconSourceElement, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IconSourceElement), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IconSourceElement[] = {
        { "icon_source", reinterpret_cast<getter>(IconSourceElement_get_IconSource), reinterpret_cast<setter>(IconSourceElement_put_IconSource), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IconSourceElement[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IconSourceElement) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IconSourceElement) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IconSourceElement) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IconSourceElement) },
        { },
    };

    static PyType_Spec type_spec_IconSourceElement =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IconSourceElement",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IconSourceElement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IconSourceElement
    };

    static PyGetSetDef getset_IconSourceElement_Static[] = {
        { "icon_source_property", reinterpret_cast<getter>(IconSourceElement_get_IconSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_IconSourceElement_Static[] = {
        { }
    };

    static PyType_Slot type_slots_IconSourceElement_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_IconSourceElement_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_IconSourceElement_Static) },
        { }
    };

    static PyType_Spec type_spec_IconSourceElement_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IconSourceElement_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_IconSourceElement_Static
    };

    // ----- Image class --------------------

    static PyObject* _new_Image(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::Microsoft::UI::Xaml::Controls::Image 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_Image(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Image_GetAlphaMask(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Image", L"GetAlphaMask", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetAlphaMask());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Image_GetAsCastingSource(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Image", L"GetAsCastingSource", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetAsCastingSource());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Image_get_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"Stretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Stretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Image_put_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"Stretch"))
        {
            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::Microsoft::UI::Xaml::Media::Stretch>(arg);

            self->obj.Stretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Image_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Source());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Image_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"Source"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.Source(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Image_get_NineGrid(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"NineGrid"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NineGrid());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Image_put_NineGrid(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"NineGrid"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.NineGrid(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Image_get_NineGridProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"NineGridProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Image::NineGridProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Image_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Image::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Image_get_StretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Image", L"StretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Image::StretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Image_add_ImageFailed(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Image", L"ImageFailed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::ExceptionRoutedEventHandler>(arg);

            return py::convert(self->obj.ImageFailed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Image_remove_ImageFailed(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Image", L"ImageFailed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ImageFailed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Image_add_ImageOpened(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Image", L"ImageOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.ImageOpened(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Image_remove_ImageOpened(py::wrapper::Microsoft::UI::Xaml::Controls::Image* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Image", L"ImageOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ImageOpened(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Image(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Image>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Image(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Image>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Image[] = {
        { "get_alpha_mask", reinterpret_cast<PyCFunction>(Image_GetAlphaMask), METH_VARARGS, nullptr },
        { "get_as_casting_source", reinterpret_cast<PyCFunction>(Image_GetAsCastingSource), METH_VARARGS, nullptr },
        { "add_image_failed", reinterpret_cast<PyCFunction>(Image_add_ImageFailed), METH_O, nullptr },
        { "remove_image_failed", reinterpret_cast<PyCFunction>(Image_remove_ImageFailed), METH_O, nullptr },
        { "add_image_opened", reinterpret_cast<PyCFunction>(Image_add_ImageOpened), METH_O, nullptr },
        { "remove_image_opened", reinterpret_cast<PyCFunction>(Image_remove_ImageOpened), METH_O, nullptr },
        { "_assign_array_", _assign_array_Image, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Image), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Image[] = {
        { "stretch", reinterpret_cast<getter>(Image_get_Stretch), reinterpret_cast<setter>(Image_put_Stretch), nullptr, nullptr },
        { "source", reinterpret_cast<getter>(Image_get_Source), reinterpret_cast<setter>(Image_put_Source), nullptr, nullptr },
        { "nine_grid", reinterpret_cast<getter>(Image_get_NineGrid), reinterpret_cast<setter>(Image_put_NineGrid), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Image[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Image) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Image) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Image) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Image) },
        { },
    };

    static PyType_Spec type_spec_Image =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Image",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Image),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Image
    };

    static PyGetSetDef getset_Image_Static[] = {
        { "nine_grid_property", reinterpret_cast<getter>(Image_get_NineGridProperty), nullptr, nullptr, nullptr },
        { "source_property", reinterpret_cast<getter>(Image_get_SourceProperty), nullptr, nullptr, nullptr },
        { "stretch_property", reinterpret_cast<getter>(Image_get_StretchProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Image_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Image_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Image_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Image_Static) },
        { }
    };

    static PyType_Spec type_spec_Image_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Image_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Image_Static
    };

    // ----- ImageIcon class --------------------

    static PyObject* _new_ImageIcon(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::Microsoft::UI::Xaml::Controls::ImageIcon 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_ImageIcon(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIcon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ImageIcon_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ImageIcon", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Source());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ImageIcon_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ImageIcon", L"Source"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.Source(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ImageIcon_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ImageIcon", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ImageIcon::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ImageIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ImageIcon>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ImageIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ImageIcon>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ImageIcon[] = {
        { "_assign_array_", _assign_array_ImageIcon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ImageIcon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ImageIcon[] = {
        { "source", reinterpret_cast<getter>(ImageIcon_get_Source), reinterpret_cast<setter>(ImageIcon_put_Source), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ImageIcon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ImageIcon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ImageIcon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ImageIcon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ImageIcon) },
        { },
    };

    static PyType_Spec type_spec_ImageIcon =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ImageIcon",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIcon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ImageIcon
    };

    static PyGetSetDef getset_ImageIcon_Static[] = {
        { "source_property", reinterpret_cast<getter>(ImageIcon_get_SourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ImageIcon_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ImageIcon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ImageIcon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ImageIcon_Static) },
        { }
    };

    static PyType_Spec type_spec_ImageIcon_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ImageIcon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ImageIcon_Static
    };

    // ----- ImageIconSource class --------------------

    static PyObject* _new_ImageIconSource(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::Microsoft::UI::Xaml::Controls::ImageIconSource 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_ImageIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIconSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ImageIconSource_get_ImageSource(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ImageIconSource", L"ImageSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ImageSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ImageIconSource_put_ImageSource(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ImageIconSource", L"ImageSource"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.ImageSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ImageIconSource_get_ImageSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ImageIconSource", L"ImageSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ImageIconSource::ImageSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ImageIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ImageIconSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ImageIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ImageIconSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ImageIconSource[] = {
        { "_assign_array_", _assign_array_ImageIconSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ImageIconSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ImageIconSource[] = {
        { "image_source", reinterpret_cast<getter>(ImageIconSource_get_ImageSource), reinterpret_cast<setter>(ImageIconSource_put_ImageSource), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ImageIconSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ImageIconSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ImageIconSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ImageIconSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ImageIconSource) },
        { },
    };

    static PyType_Spec type_spec_ImageIconSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ImageIconSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ImageIconSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ImageIconSource
    };

    static PyGetSetDef getset_ImageIconSource_Static[] = {
        { "image_source_property", reinterpret_cast<getter>(ImageIconSource_get_ImageSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ImageIconSource_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ImageIconSource_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ImageIconSource_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ImageIconSource_Static) },
        { }
    };

    static PyType_Spec type_spec_ImageIconSource_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ImageIconSource_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ImageIconSource_Static
    };

    // ----- InfoBadge class --------------------

    static PyObject* _new_InfoBadge(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::Microsoft::UI::Xaml::Controls::InfoBadge 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_InfoBadge(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadge* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* InfoBadge_get_Value(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadge* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", 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 InfoBadge_put_Value(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadge* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", 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<int32_t>(arg);

            self->obj.Value(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBadge_get_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadge* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", L"IconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBadge_put_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadge* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", L"IconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

            self->obj.IconSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBadge_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadge* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBadge_get_IconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", L"IconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBadge::IconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBadge_get_TemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", L"TemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBadge::TemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBadge_get_ValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadge", L"ValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBadge::ValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_InfoBadge(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::InfoBadge>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_InfoBadge(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::InfoBadge>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_InfoBadge[] = {
        { "_assign_array_", _assign_array_InfoBadge, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_InfoBadge), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_InfoBadge[] = {
        { "value", reinterpret_cast<getter>(InfoBadge_get_Value), reinterpret_cast<setter>(InfoBadge_put_Value), nullptr, nullptr },
        { "icon_source", reinterpret_cast<getter>(InfoBadge_get_IconSource), reinterpret_cast<setter>(InfoBadge_put_IconSource), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(InfoBadge_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_InfoBadge[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_InfoBadge) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_InfoBadge) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_InfoBadge) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_InfoBadge) },
        { },
    };

    static PyType_Spec type_spec_InfoBadge =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBadge",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadge),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_InfoBadge
    };

    static PyGetSetDef getset_InfoBadge_Static[] = {
        { "icon_source_property", reinterpret_cast<getter>(InfoBadge_get_IconSourceProperty), nullptr, nullptr, nullptr },
        { "template_settings_property", reinterpret_cast<getter>(InfoBadge_get_TemplateSettingsProperty), nullptr, nullptr, nullptr },
        { "value_property", reinterpret_cast<getter>(InfoBadge_get_ValueProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_InfoBadge_Static[] = {
        { }
    };

    static PyType_Slot type_slots_InfoBadge_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_InfoBadge_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_InfoBadge_Static) },
        { }
    };

    static PyType_Spec type_spec_InfoBadge_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBadge_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_InfoBadge_Static
    };

    // ----- InfoBadgeTemplateSettings class --------------------

    static PyObject* _new_InfoBadgeTemplateSettings(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::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings 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_InfoBadgeTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* InfoBadgeTemplateSettings_get_InfoBadgeCornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings", L"InfoBadgeCornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InfoBadgeCornerRadius());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBadgeTemplateSettings_put_InfoBadgeCornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings", L"InfoBadgeCornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

            self->obj.InfoBadgeCornerRadius(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBadgeTemplateSettings_get_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings", L"IconElement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconElement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBadgeTemplateSettings_put_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings", L"IconElement"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.IconElement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBadgeTemplateSettings_get_IconElementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings", L"IconElementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings::IconElementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBadgeTemplateSettings_get_InfoBadgeCornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings", L"InfoBadgeCornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings::InfoBadgeCornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_InfoBadgeTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_InfoBadgeTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_InfoBadgeTemplateSettings[] = {
        { "_assign_array_", _assign_array_InfoBadgeTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_InfoBadgeTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_InfoBadgeTemplateSettings[] = {
        { "info_badge_corner_radius", reinterpret_cast<getter>(InfoBadgeTemplateSettings_get_InfoBadgeCornerRadius), reinterpret_cast<setter>(InfoBadgeTemplateSettings_put_InfoBadgeCornerRadius), nullptr, nullptr },
        { "icon_element", reinterpret_cast<getter>(InfoBadgeTemplateSettings_get_IconElement), reinterpret_cast<setter>(InfoBadgeTemplateSettings_put_IconElement), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_InfoBadgeTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_InfoBadgeTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_InfoBadgeTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_InfoBadgeTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_InfoBadgeTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_InfoBadgeTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBadgeTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBadgeTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_InfoBadgeTemplateSettings
    };

    static PyGetSetDef getset_InfoBadgeTemplateSettings_Static[] = {
        { "icon_element_property", reinterpret_cast<getter>(InfoBadgeTemplateSettings_get_IconElementProperty), nullptr, nullptr, nullptr },
        { "info_badge_corner_radius_property", reinterpret_cast<getter>(InfoBadgeTemplateSettings_get_InfoBadgeCornerRadiusProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_InfoBadgeTemplateSettings_Static[] = {
        { }
    };

    static PyType_Slot type_slots_InfoBadgeTemplateSettings_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_InfoBadgeTemplateSettings_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_InfoBadgeTemplateSettings_Static) },
        { }
    };

    static PyType_Spec type_spec_InfoBadgeTemplateSettings_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBadgeTemplateSettings_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_InfoBadgeTemplateSettings_Static
    };

    // ----- InfoBar class --------------------

    static PyObject* _new_InfoBar(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::Microsoft::UI::Xaml::Controls::InfoBar 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_InfoBar(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* InfoBar_get_Title(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Title"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Title());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_Title(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Title"))
        {
            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.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_Severity(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Severity"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Severity());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_Severity(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Severity"))
        {
            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::Microsoft::UI::Xaml::Controls::InfoBarSeverity>(arg);

            self->obj.Severity(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_Message(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Message"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Message());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_Message(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Message"))
        {
            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.Message(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsOpen());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsOpen"))
        {
            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.IsOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_IsIconVisible(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsIconVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsIconVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_IsIconVisible(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsIconVisible"))
        {
            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.IsIconVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_IsClosable(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsClosable"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsClosable());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_IsClosable(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsClosable"))
        {
            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.IsClosable(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

            self->obj.IconSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"ContentTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_ContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"ContentTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.ContentTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Content"))
        {
            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.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_CloseButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_CloseButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.CloseButtonStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_CloseButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonCommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonCommandParameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_CloseButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonCommandParameter"))
        {
            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.CloseButtonCommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_CloseButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonCommand"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonCommand());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_CloseButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonCommand"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

            self->obj.CloseButtonCommand(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_ActionButton(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"ActionButton"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActionButton());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBar_put_ActionButton(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"ActionButton"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::ButtonBase>(arg);

            self->obj.ActionButton(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBar_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_ActionButtonProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"ActionButtonProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::ActionButtonProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_CloseButtonCommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonCommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::CloseButtonCommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_CloseButtonCommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonCommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::CloseButtonCommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_CloseButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::CloseButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_ContentTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"ContentTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::ContentTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_IconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::IconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_IsClosableProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsClosableProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::IsClosableProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_IsIconVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsIconVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::IsIconVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_IsOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"IsOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::IsOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_MessageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"MessageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::MessageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_SeverityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"SeverityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::SeverityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_TemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"TemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::TemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_get_TitleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"TitleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBar::TitleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_add_CloseButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::InfoBar, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.CloseButtonClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_remove_CloseButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"CloseButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CloseButtonClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_add_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::InfoBar, winrt::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs>>(arg);

            return py::convert(self->obj.Closed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_remove_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Closed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_add_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::InfoBar, winrt::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs>>(arg);

            return py::convert(self->obj.Closing(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* InfoBar_remove_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.InfoBar", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Closing(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_InfoBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::InfoBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_InfoBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::InfoBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_InfoBar[] = {
        { "add_close_button_click", reinterpret_cast<PyCFunction>(InfoBar_add_CloseButtonClick), METH_O, nullptr },
        { "remove_close_button_click", reinterpret_cast<PyCFunction>(InfoBar_remove_CloseButtonClick), METH_O, nullptr },
        { "add_closed", reinterpret_cast<PyCFunction>(InfoBar_add_Closed), METH_O, nullptr },
        { "remove_closed", reinterpret_cast<PyCFunction>(InfoBar_remove_Closed), METH_O, nullptr },
        { "add_closing", reinterpret_cast<PyCFunction>(InfoBar_add_Closing), METH_O, nullptr },
        { "remove_closing", reinterpret_cast<PyCFunction>(InfoBar_remove_Closing), METH_O, nullptr },
        { "_assign_array_", _assign_array_InfoBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_InfoBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_InfoBar[] = {
        { "title", reinterpret_cast<getter>(InfoBar_get_Title), reinterpret_cast<setter>(InfoBar_put_Title), nullptr, nullptr },
        { "severity", reinterpret_cast<getter>(InfoBar_get_Severity), reinterpret_cast<setter>(InfoBar_put_Severity), nullptr, nullptr },
        { "message", reinterpret_cast<getter>(InfoBar_get_Message), reinterpret_cast<setter>(InfoBar_put_Message), nullptr, nullptr },
        { "is_open", reinterpret_cast<getter>(InfoBar_get_IsOpen), reinterpret_cast<setter>(InfoBar_put_IsOpen), nullptr, nullptr },
        { "is_icon_visible", reinterpret_cast<getter>(InfoBar_get_IsIconVisible), reinterpret_cast<setter>(InfoBar_put_IsIconVisible), nullptr, nullptr },
        { "is_closable", reinterpret_cast<getter>(InfoBar_get_IsClosable), reinterpret_cast<setter>(InfoBar_put_IsClosable), nullptr, nullptr },
        { "icon_source", reinterpret_cast<getter>(InfoBar_get_IconSource), reinterpret_cast<setter>(InfoBar_put_IconSource), nullptr, nullptr },
        { "content_template", reinterpret_cast<getter>(InfoBar_get_ContentTemplate), reinterpret_cast<setter>(InfoBar_put_ContentTemplate), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(InfoBar_get_Content), reinterpret_cast<setter>(InfoBar_put_Content), nullptr, nullptr },
        { "close_button_style", reinterpret_cast<getter>(InfoBar_get_CloseButtonStyle), reinterpret_cast<setter>(InfoBar_put_CloseButtonStyle), nullptr, nullptr },
        { "close_button_command_parameter", reinterpret_cast<getter>(InfoBar_get_CloseButtonCommandParameter), reinterpret_cast<setter>(InfoBar_put_CloseButtonCommandParameter), nullptr, nullptr },
        { "close_button_command", reinterpret_cast<getter>(InfoBar_get_CloseButtonCommand), reinterpret_cast<setter>(InfoBar_put_CloseButtonCommand), nullptr, nullptr },
        { "action_button", reinterpret_cast<getter>(InfoBar_get_ActionButton), reinterpret_cast<setter>(InfoBar_put_ActionButton), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(InfoBar_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_InfoBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_InfoBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_InfoBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_InfoBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_InfoBar) },
        { },
    };

    static PyType_Spec type_spec_InfoBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_InfoBar
    };

    static PyGetSetDef getset_InfoBar_Static[] = {
        { "action_button_property", reinterpret_cast<getter>(InfoBar_get_ActionButtonProperty), nullptr, nullptr, nullptr },
        { "close_button_command_parameter_property", reinterpret_cast<getter>(InfoBar_get_CloseButtonCommandParameterProperty), nullptr, nullptr, nullptr },
        { "close_button_command_property", reinterpret_cast<getter>(InfoBar_get_CloseButtonCommandProperty), nullptr, nullptr, nullptr },
        { "close_button_style_property", reinterpret_cast<getter>(InfoBar_get_CloseButtonStyleProperty), nullptr, nullptr, nullptr },
        { "content_property", reinterpret_cast<getter>(InfoBar_get_ContentProperty), nullptr, nullptr, nullptr },
        { "content_template_property", reinterpret_cast<getter>(InfoBar_get_ContentTemplateProperty), nullptr, nullptr, nullptr },
        { "icon_source_property", reinterpret_cast<getter>(InfoBar_get_IconSourceProperty), nullptr, nullptr, nullptr },
        { "is_closable_property", reinterpret_cast<getter>(InfoBar_get_IsClosableProperty), nullptr, nullptr, nullptr },
        { "is_icon_visible_property", reinterpret_cast<getter>(InfoBar_get_IsIconVisibleProperty), nullptr, nullptr, nullptr },
        { "is_open_property", reinterpret_cast<getter>(InfoBar_get_IsOpenProperty), nullptr, nullptr, nullptr },
        { "message_property", reinterpret_cast<getter>(InfoBar_get_MessageProperty), nullptr, nullptr, nullptr },
        { "severity_property", reinterpret_cast<getter>(InfoBar_get_SeverityProperty), nullptr, nullptr, nullptr },
        { "template_settings_property", reinterpret_cast<getter>(InfoBar_get_TemplateSettingsProperty), nullptr, nullptr, nullptr },
        { "title_property", reinterpret_cast<getter>(InfoBar_get_TitleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_InfoBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_InfoBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_InfoBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_InfoBar_Static) },
        { }
    };

    static PyType_Spec type_spec_InfoBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_InfoBar_Static
    };

    // ----- InfoBarClosedEventArgs class --------------------

    static PyObject* _new_InfoBarClosedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_InfoBarClosedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* InfoBarClosedEventArgs_get_Reason(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBarClosedEventArgs", L"Reason"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Reason());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_InfoBarClosedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_InfoBarClosedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_InfoBarClosedEventArgs[] = {
        { "_assign_array_", _assign_array_InfoBarClosedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_InfoBarClosedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_InfoBarClosedEventArgs[] = {
        { "reason", reinterpret_cast<getter>(InfoBarClosedEventArgs_get_Reason), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_InfoBarClosedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_InfoBarClosedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_InfoBarClosedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_InfoBarClosedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_InfoBarClosedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_InfoBarClosedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBarClosedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_InfoBarClosedEventArgs
    };

    // ----- InfoBarClosingEventArgs class --------------------

    static PyObject* _new_InfoBarClosingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_InfoBarClosingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* InfoBarClosingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBarClosingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBarClosingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBarClosingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBarClosingEventArgs_get_Reason(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBarClosingEventArgs", L"Reason"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Reason());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_InfoBarClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_InfoBarClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_InfoBarClosingEventArgs[] = {
        { "_assign_array_", _assign_array_InfoBarClosingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_InfoBarClosingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_InfoBarClosingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(InfoBarClosingEventArgs_get_Cancel), reinterpret_cast<setter>(InfoBarClosingEventArgs_put_Cancel), nullptr, nullptr },
        { "reason", reinterpret_cast<getter>(InfoBarClosingEventArgs_get_Reason), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_InfoBarClosingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_InfoBarClosingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_InfoBarClosingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_InfoBarClosingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_InfoBarClosingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_InfoBarClosingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBarClosingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarClosingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_InfoBarClosingEventArgs
    };

    // ----- InfoBarTemplateSettings class --------------------

    static PyObject* _new_InfoBarTemplateSettings(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::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings 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_InfoBarTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* InfoBarTemplateSettings_get_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBarTemplateSettings", L"IconElement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconElement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int InfoBarTemplateSettings_put_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBarTemplateSettings", L"IconElement"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.IconElement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* InfoBarTemplateSettings_get_IconElementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.InfoBarTemplateSettings", L"IconElementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings::IconElementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_InfoBarTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_InfoBarTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_InfoBarTemplateSettings[] = {
        { "_assign_array_", _assign_array_InfoBarTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_InfoBarTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_InfoBarTemplateSettings[] = {
        { "icon_element", reinterpret_cast<getter>(InfoBarTemplateSettings_get_IconElement), reinterpret_cast<setter>(InfoBarTemplateSettings_put_IconElement), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_InfoBarTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_InfoBarTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_InfoBarTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_InfoBarTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_InfoBarTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_InfoBarTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBarTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::InfoBarTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_InfoBarTemplateSettings
    };

    static PyGetSetDef getset_InfoBarTemplateSettings_Static[] = {
        { "icon_element_property", reinterpret_cast<getter>(InfoBarTemplateSettings_get_IconElementProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_InfoBarTemplateSettings_Static[] = {
        { }
    };

    static PyType_Slot type_slots_InfoBarTemplateSettings_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_InfoBarTemplateSettings_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_InfoBarTemplateSettings_Static) },
        { }
    };

    static PyType_Spec type_spec_InfoBarTemplateSettings_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.InfoBarTemplateSettings_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_InfoBarTemplateSettings_Static
    };

    // ----- IsTextTrimmedChangedEventArgs class --------------------

    static PyObject* _new_IsTextTrimmedChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_IsTextTrimmedChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_IsTextTrimmedChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IsTextTrimmedChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsTextTrimmedChangedEventArgs[] = {
        { "_assign_array_", _assign_array_IsTextTrimmedChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IsTextTrimmedChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsTextTrimmedChangedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_IsTextTrimmedChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IsTextTrimmedChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IsTextTrimmedChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IsTextTrimmedChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IsTextTrimmedChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_IsTextTrimmedChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IsTextTrimmedChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsTextTrimmedChangedEventArgs
    };

    // ----- ItemClickEventArgs class --------------------

    static PyObject* _new_ItemClickEventArgs(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::Microsoft::UI::Xaml::Controls::ItemClickEventArgs 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_ItemClickEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemClickEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemClickEventArgs_get_ClickedItem(py::wrapper::Microsoft::UI::Xaml::Controls::ItemClickEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemClickEventArgs", L"ClickedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ClickedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemClickEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemClickEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemClickEventArgs[] = {
        { "_assign_array_", _assign_array_ItemClickEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemClickEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemClickEventArgs[] = {
        { "clicked_item", reinterpret_cast<getter>(ItemClickEventArgs_get_ClickedItem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemClickEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemClickEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemClickEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemClickEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemClickEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemClickEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemClickEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemClickEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemClickEventArgs
    };

    // ----- ItemCollection class --------------------

    static PyObject* _new_ItemCollection(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollection>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollection>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemCollection_Append(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"Append", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                self->obj.Append(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_Clear(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"Clear", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Clear();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_First(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", 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* ItemCollection_GetAt(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", 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* ItemCollection_GetMany(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", 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::Foundation::IInspectable, 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* ItemCollection_GetView(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"GetView", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetView());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_IndexOf(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(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* ItemCollection_InsertAt(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"InsertAt", 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::Windows::Foundation::IInspectable>(args, 1);

                self->obj.InsertAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_RemoveAt(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"RemoveAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);

                self->obj.RemoveAt(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_RemoveAtEnd(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"RemoveAtEnd", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RemoveAtEnd();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_ReplaceAll(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"ReplaceAll", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<winrt::Windows::Foundation::IInspectable, false>>(args, 0);

                self->obj.ReplaceAll(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_SetAt(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"SetAt", 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::Windows::Foundation::IInspectable>(args, 1);

                self->obj.SetAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollection_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", 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* ItemCollection_add_VectorChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"VectorChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::VectorChangedEventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.VectorChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollection_remove_VectorChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemCollection", L"VectorChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.VectorChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemCollection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemCollection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_ItemCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_ItemCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_ItemCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* 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_ItemCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* 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_ItemCollection(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::Foundation::IInspectable> items(static_cast<uint32_t>(length), empty_instance<winrt::Windows::Foundation::IInspectable>::get());

            auto count = self->obj.GetMany(static_cast<uint32_t>(start), items);

            if (count != static_cast<uint32_t>(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 int _seq_assign_ItemCollection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection* self, Py_ssize_t i, PyObject* value) noexcept
    {
        try
        {
            if (value == nullptr) { self->obj.RemoveAt(static_cast<uint32_t>(i)); }
            else { self->obj.SetAt(static_cast<uint32_t>(i), py::convert_to<winrt::Windows::Foundation::IInspectable>(value)); }
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyMethodDef _methods_ItemCollection[] = {
        { "append", reinterpret_cast<PyCFunction>(ItemCollection_Append), METH_VARARGS, nullptr },
        { "clear", reinterpret_cast<PyCFunction>(ItemCollection_Clear), METH_VARARGS, nullptr },
        { "first", reinterpret_cast<PyCFunction>(ItemCollection_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(ItemCollection_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(ItemCollection_GetMany), METH_VARARGS, nullptr },
        { "get_view", reinterpret_cast<PyCFunction>(ItemCollection_GetView), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(ItemCollection_IndexOf), METH_VARARGS, nullptr },
        { "insert_at", reinterpret_cast<PyCFunction>(ItemCollection_InsertAt), METH_VARARGS, nullptr },
        { "remove_at", reinterpret_cast<PyCFunction>(ItemCollection_RemoveAt), METH_VARARGS, nullptr },
        { "remove_at_end", reinterpret_cast<PyCFunction>(ItemCollection_RemoveAtEnd), METH_VARARGS, nullptr },
        { "replace_all", reinterpret_cast<PyCFunction>(ItemCollection_ReplaceAll), METH_VARARGS, nullptr },
        { "set_at", reinterpret_cast<PyCFunction>(ItemCollection_SetAt), METH_VARARGS, nullptr },
        { "add_vector_changed", reinterpret_cast<PyCFunction>(ItemCollection_add_VectorChanged), METH_O, nullptr },
        { "remove_vector_changed", reinterpret_cast<PyCFunction>(ItemCollection_remove_VectorChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_ItemCollection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemCollection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemCollection[] = {
        { "size", reinterpret_cast<getter>(ItemCollection_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemCollection[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemCollection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemCollection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemCollection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemCollection) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_ItemCollection) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_ItemCollection) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_ItemCollection) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_ItemCollection) },
        { Py_sq_ass_item, reinterpret_cast<void*>(_seq_assign_ItemCollection) },
        { },
    };

    static PyType_Spec type_spec_ItemCollection =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemCollection",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemCollection
    };

    // ----- ItemCollectionTransition class --------------------

    static PyObject* _new_ItemCollectionTransition(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransition>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransition>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemCollectionTransition(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemCollectionTransition_Start(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransition", L"Start", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.Start());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransition_get_HasStarted(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransition", L"HasStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasStarted());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransition_get_NewBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransition", L"NewBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewBounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransition_get_OldBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransition", L"OldBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OldBounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransition_get_Operation(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransition", L"Operation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Operation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransition_get_Triggers(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransition", L"Triggers"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Triggers());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemCollectionTransition(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransition>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemCollectionTransition(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransition>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemCollectionTransition[] = {
        { "start", reinterpret_cast<PyCFunction>(ItemCollectionTransition_Start), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ItemCollectionTransition, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemCollectionTransition), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemCollectionTransition[] = {
        { "has_started", reinterpret_cast<getter>(ItemCollectionTransition_get_HasStarted), nullptr, nullptr, nullptr },
        { "new_bounds", reinterpret_cast<getter>(ItemCollectionTransition_get_NewBounds), nullptr, nullptr, nullptr },
        { "old_bounds", reinterpret_cast<getter>(ItemCollectionTransition_get_OldBounds), nullptr, nullptr, nullptr },
        { "operation", reinterpret_cast<getter>(ItemCollectionTransition_get_Operation), nullptr, nullptr, nullptr },
        { "triggers", reinterpret_cast<getter>(ItemCollectionTransition_get_Triggers), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemCollectionTransition[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemCollectionTransition) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemCollectionTransition) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemCollectionTransition) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemCollectionTransition) },
        { },
    };

    static PyType_Spec type_spec_ItemCollectionTransition =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemCollectionTransition",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransition),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemCollectionTransition
    };

    // ----- ItemCollectionTransitionCompletedEventArgs class --------------------

    static PyObject* _new_ItemCollectionTransitionCompletedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemCollectionTransitionCompletedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemCollectionTransitionCompletedEventArgs_get_Element(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionCompletedEventArgs", L"Element"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Element());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransitionCompletedEventArgs_get_Transition(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionCompletedEventArgs", L"Transition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Transition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemCollectionTransitionCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemCollectionTransitionCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemCollectionTransitionCompletedEventArgs[] = {
        { "_assign_array_", _assign_array_ItemCollectionTransitionCompletedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemCollectionTransitionCompletedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemCollectionTransitionCompletedEventArgs[] = {
        { "element", reinterpret_cast<getter>(ItemCollectionTransitionCompletedEventArgs_get_Element), nullptr, nullptr, nullptr },
        { "transition", reinterpret_cast<getter>(ItemCollectionTransitionCompletedEventArgs_get_Transition), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemCollectionTransitionCompletedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemCollectionTransitionCompletedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemCollectionTransitionCompletedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemCollectionTransitionCompletedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemCollectionTransitionCompletedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemCollectionTransitionCompletedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemCollectionTransitionCompletedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemCollectionTransitionCompletedEventArgs
    };

    // ----- ItemCollectionTransitionProgress class --------------------

    static PyObject* _new_ItemCollectionTransitionProgress(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemCollectionTransitionProgress(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemCollectionTransitionProgress_Complete(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProgress", L"Complete", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Complete();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransitionProgress_get_Element(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProgress", L"Element"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Element());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransitionProgress_get_Transition(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProgress", L"Transition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Transition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemCollectionTransitionProgress(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemCollectionTransitionProgress(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemCollectionTransitionProgress[] = {
        { "complete", reinterpret_cast<PyCFunction>(ItemCollectionTransitionProgress_Complete), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ItemCollectionTransitionProgress, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemCollectionTransitionProgress), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemCollectionTransitionProgress[] = {
        { "element", reinterpret_cast<getter>(ItemCollectionTransitionProgress_get_Element), nullptr, nullptr, nullptr },
        { "transition", reinterpret_cast<getter>(ItemCollectionTransitionProgress_get_Transition), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemCollectionTransitionProgress[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemCollectionTransitionProgress) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemCollectionTransitionProgress) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemCollectionTransitionProgress) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemCollectionTransitionProgress) },
        { },
    };

    static PyType_Spec type_spec_ItemCollectionTransitionProgress =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemCollectionTransitionProgress",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProgress),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemCollectionTransitionProgress
    };

    // ----- ItemCollectionTransitionProvider class --------------------

    static PyObject* _new_ItemCollectionTransitionProvider(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::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider 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_ItemCollectionTransitionProvider(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemCollectionTransitionProvider_QueueTransition(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider", L"QueueTransition", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransition>(args, 0);

                self->obj.QueueTransition(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransitionProvider_ShouldAnimate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider", L"ShouldAnimate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransition>(args, 0);

                return py::convert(self->obj.ShouldAnimate(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransitionProvider_add_TransitionCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider", L"TransitionCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider, winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionCompletedEventArgs>>(arg);

            return py::convert(self->obj.TransitionCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemCollectionTransitionProvider_remove_TransitionCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider", L"TransitionCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TransitionCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemCollectionTransitionProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemCollectionTransitionProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemCollectionTransitionProvider[] = {
        { "queue_transition", reinterpret_cast<PyCFunction>(ItemCollectionTransitionProvider_QueueTransition), METH_VARARGS, nullptr },
        { "should_animate", reinterpret_cast<PyCFunction>(ItemCollectionTransitionProvider_ShouldAnimate), METH_VARARGS, nullptr },
        { "add_transition_completed", reinterpret_cast<PyCFunction>(ItemCollectionTransitionProvider_add_TransitionCompleted), METH_O, nullptr },
        { "remove_transition_completed", reinterpret_cast<PyCFunction>(ItemCollectionTransitionProvider_remove_TransitionCompleted), METH_O, nullptr },
        { "_assign_array_", _assign_array_ItemCollectionTransitionProvider, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemCollectionTransitionProvider), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemCollectionTransitionProvider[] = {
        { }
    };

    static PyType_Slot _type_slots_ItemCollectionTransitionProvider[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemCollectionTransitionProvider) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemCollectionTransitionProvider) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemCollectionTransitionProvider) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemCollectionTransitionProvider) },
        { },
    };

    static PyType_Spec type_spec_ItemCollectionTransitionProvider =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemCollectionTransitionProvider",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemCollectionTransitionProvider
    };

    // ----- ItemContainer class --------------------

    static PyObject* _new_ItemContainer(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::Microsoft::UI::Xaml::Controls::ItemContainer 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_ItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemContainer_get_IsSelected(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemContainer", L"IsSelected"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSelected());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemContainer_put_IsSelected(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemContainer", L"IsSelected"))
        {
            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.IsSelected(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemContainer_get_Child(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemContainer", L"Child"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Child());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemContainer_put_Child(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemContainer", L"Child"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Child(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemContainer_get_ChildProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemContainer", L"ChildProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemContainer::ChildProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemContainer_get_IsSelectedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemContainer", L"IsSelectedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemContainer::IsSelectedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemContainer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemContainer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemContainer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemContainer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemContainer[] = {
        { "_assign_array_", _assign_array_ItemContainer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemContainer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemContainer[] = {
        { "is_selected", reinterpret_cast<getter>(ItemContainer_get_IsSelected), reinterpret_cast<setter>(ItemContainer_put_IsSelected), nullptr, nullptr },
        { "child", reinterpret_cast<getter>(ItemContainer_get_Child), reinterpret_cast<setter>(ItemContainer_put_Child), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemContainer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemContainer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemContainer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemContainer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemContainer) },
        { },
    };

    static PyType_Spec type_spec_ItemContainer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemContainer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemContainer
    };

    static PyGetSetDef getset_ItemContainer_Static[] = {
        { "child_property", reinterpret_cast<getter>(ItemContainer_get_ChildProperty), nullptr, nullptr, nullptr },
        { "is_selected_property", reinterpret_cast<getter>(ItemContainer_get_IsSelectedProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ItemContainer_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ItemContainer_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ItemContainer_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ItemContainer_Static) },
        { }
    };

    static PyType_Spec type_spec_ItemContainer_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemContainer_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ItemContainer_Static
    };

    // ----- ItemContainerGenerator class --------------------

    static PyObject* _new_ItemContainerGenerator(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemContainerGenerator>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemContainerGenerator>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemContainerGenerator(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemContainerGenerator_ContainerFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"ContainerFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.ContainerFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_ContainerFromItem(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"ContainerFromItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.ContainerFromItem(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_GenerateNext(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"GenerateNext", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                bool param0 {  };

                auto return_value = self->obj.GenerateNext(param0);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out0{ py::convert(param0) };
                if (!out0)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out0.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_GeneratorPositionFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"GeneratorPositionFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.GeneratorPositionFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_GetItemContainerGeneratorForPanel(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"GetItemContainerGeneratorForPanel", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Panel>(args, 0);

                return py::convert(self->obj.GetItemContainerGeneratorForPanel(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_IndexFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"IndexFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.IndexFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_IndexFromGeneratorPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"IndexFromGeneratorPosition", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::GeneratorPosition>(args, 0);

                return py::convert(self->obj.IndexFromGeneratorPosition(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_ItemFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"ItemFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.ItemFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_PrepareItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"PrepareItemContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                self->obj.PrepareItemContainer(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_Recycle(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"Recycle", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::GeneratorPosition>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                self->obj.Recycle(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_Remove(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"Remove", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::GeneratorPosition>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                self->obj.Remove(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_RemoveAll(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"RemoveAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RemoveAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_StartAt(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"StartAt", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::GeneratorPosition>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::GeneratorDirection>(args, 1);
                auto param2 = py::convert_to<bool>(args, 2);

                self->obj.StartAt(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* ItemContainerGenerator_Stop(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"Stop", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Stop();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_add_ItemsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"ItemsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::ItemsChangedEventHandler>(arg);

            return py::convert(self->obj.ItemsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemContainerGenerator_remove_ItemsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemContainerGenerator", L"ItemsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemContainerGenerator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemContainerGenerator>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemContainerGenerator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemContainerGenerator>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemContainerGenerator[] = {
        { "container_from_index", reinterpret_cast<PyCFunction>(ItemContainerGenerator_ContainerFromIndex), METH_VARARGS, nullptr },
        { "container_from_item", reinterpret_cast<PyCFunction>(ItemContainerGenerator_ContainerFromItem), METH_VARARGS, nullptr },
        { "generate_next", reinterpret_cast<PyCFunction>(ItemContainerGenerator_GenerateNext), METH_VARARGS, nullptr },
        { "generator_position_from_index", reinterpret_cast<PyCFunction>(ItemContainerGenerator_GeneratorPositionFromIndex), METH_VARARGS, nullptr },
        { "get_item_container_generator_for_panel", reinterpret_cast<PyCFunction>(ItemContainerGenerator_GetItemContainerGeneratorForPanel), METH_VARARGS, nullptr },
        { "index_from_container", reinterpret_cast<PyCFunction>(ItemContainerGenerator_IndexFromContainer), METH_VARARGS, nullptr },
        { "index_from_generator_position", reinterpret_cast<PyCFunction>(ItemContainerGenerator_IndexFromGeneratorPosition), METH_VARARGS, nullptr },
        { "item_from_container", reinterpret_cast<PyCFunction>(ItemContainerGenerator_ItemFromContainer), METH_VARARGS, nullptr },
        { "prepare_item_container", reinterpret_cast<PyCFunction>(ItemContainerGenerator_PrepareItemContainer), METH_VARARGS, nullptr },
        { "recycle", reinterpret_cast<PyCFunction>(ItemContainerGenerator_Recycle), METH_VARARGS, nullptr },
        { "remove", reinterpret_cast<PyCFunction>(ItemContainerGenerator_Remove), METH_VARARGS, nullptr },
        { "remove_all", reinterpret_cast<PyCFunction>(ItemContainerGenerator_RemoveAll), METH_VARARGS, nullptr },
        { "start_at", reinterpret_cast<PyCFunction>(ItemContainerGenerator_StartAt), METH_VARARGS, nullptr },
        { "stop", reinterpret_cast<PyCFunction>(ItemContainerGenerator_Stop), METH_VARARGS, nullptr },
        { "add_items_changed", reinterpret_cast<PyCFunction>(ItemContainerGenerator_add_ItemsChanged), METH_O, nullptr },
        { "remove_items_changed", reinterpret_cast<PyCFunction>(ItemContainerGenerator_remove_ItemsChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_ItemContainerGenerator, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemContainerGenerator), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemContainerGenerator[] = {
        { }
    };

    static PyType_Slot _type_slots_ItemContainerGenerator[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemContainerGenerator) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemContainerGenerator) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemContainerGenerator) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemContainerGenerator) },
        { },
    };

    static PyType_Spec type_spec_ItemContainerGenerator =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemContainerGenerator",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemContainerGenerator),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemContainerGenerator
    };

    // ----- ItemsControl class --------------------

    static PyObject* _new_ItemsControl(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::Microsoft::UI::Xaml::Controls::ItemsControl 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_ItemsControl(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsControl_ContainerFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ContainerFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.ContainerFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsControl_ContainerFromItem(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ContainerFromItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.ContainerFromItem(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsControl_GetItemsOwner(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"GetItemsOwner", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::GetItemsOwner(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsControl_GroupHeaderContainerFromItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"GroupHeaderContainerFromItemContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.GroupHeaderContainerFromItemContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsControl_IndexFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"IndexFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.IndexFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsControl_ItemFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.ItemFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsControl_ItemsControlFromItemContainer(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsControlFromItemContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemsControlFromItemContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_ItemsPanel(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsPanel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsPanel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_ItemsPanel(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsPanel"))
        {
            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::Microsoft::UI::Xaml::Controls::ItemsPanelTemplate>(arg);

            self->obj.ItemsPanel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_ItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplateSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_ItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

            self->obj.ItemTemplateSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.ItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_ItemContainerTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerTransitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_ItemContainerTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

            self->obj.ItemContainerTransitions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_ItemContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerStyleSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerStyleSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_ItemContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerStyleSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::StyleSelector>(arg);

            self->obj.ItemContainerStyleSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_ItemContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_ItemContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.ItemContainerStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_GroupStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"GroupStyleSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupStyleSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_GroupStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"GroupStyleSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::GroupStyleSelector>(arg);

            self->obj.GroupStyleSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_DisplayMemberPath(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"DisplayMemberPath"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisplayMemberPath());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsControl_put_DisplayMemberPath(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"DisplayMemberPath"))
        {
            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.DisplayMemberPath(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsControl_get_GroupStyle(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"GroupStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_IsGrouping(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"IsGrouping"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsGrouping());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemContainerGenerator(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerGenerator"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerGenerator());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemsPanelRoot(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsPanelRoot"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsPanelRoot());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_DisplayMemberPathProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"DisplayMemberPathProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::DisplayMemberPathProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_GroupStyleSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"GroupStyleSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::GroupStyleSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_IsGroupingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"IsGroupingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::IsGroupingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemContainerStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemContainerStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemContainerStyleSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerStyleSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemContainerStyleSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemContainerTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemContainerTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemContainerTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemTemplateSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemTemplateSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemTemplateSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemsPanelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsPanelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemsPanelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsControl_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsControl", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsControl::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsControl>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsControl[] = {
        { "container_from_index", reinterpret_cast<PyCFunction>(ItemsControl_ContainerFromIndex), METH_VARARGS, nullptr },
        { "container_from_item", reinterpret_cast<PyCFunction>(ItemsControl_ContainerFromItem), METH_VARARGS, nullptr },
        { "group_header_container_from_item_container", reinterpret_cast<PyCFunction>(ItemsControl_GroupHeaderContainerFromItemContainer), METH_VARARGS, nullptr },
        { "index_from_container", reinterpret_cast<PyCFunction>(ItemsControl_IndexFromContainer), METH_VARARGS, nullptr },
        { "item_from_container", reinterpret_cast<PyCFunction>(ItemsControl_ItemFromContainer), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ItemsControl, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsControl[] = {
        { "items_source", reinterpret_cast<getter>(ItemsControl_get_ItemsSource), reinterpret_cast<setter>(ItemsControl_put_ItemsSource), nullptr, nullptr },
        { "items_panel", reinterpret_cast<getter>(ItemsControl_get_ItemsPanel), reinterpret_cast<setter>(ItemsControl_put_ItemsPanel), nullptr, nullptr },
        { "item_template_selector", reinterpret_cast<getter>(ItemsControl_get_ItemTemplateSelector), reinterpret_cast<setter>(ItemsControl_put_ItemTemplateSelector), nullptr, nullptr },
        { "item_template", reinterpret_cast<getter>(ItemsControl_get_ItemTemplate), reinterpret_cast<setter>(ItemsControl_put_ItemTemplate), nullptr, nullptr },
        { "item_container_transitions", reinterpret_cast<getter>(ItemsControl_get_ItemContainerTransitions), reinterpret_cast<setter>(ItemsControl_put_ItemContainerTransitions), nullptr, nullptr },
        { "item_container_style_selector", reinterpret_cast<getter>(ItemsControl_get_ItemContainerStyleSelector), reinterpret_cast<setter>(ItemsControl_put_ItemContainerStyleSelector), nullptr, nullptr },
        { "item_container_style", reinterpret_cast<getter>(ItemsControl_get_ItemContainerStyle), reinterpret_cast<setter>(ItemsControl_put_ItemContainerStyle), nullptr, nullptr },
        { "group_style_selector", reinterpret_cast<getter>(ItemsControl_get_GroupStyleSelector), reinterpret_cast<setter>(ItemsControl_put_GroupStyleSelector), nullptr, nullptr },
        { "display_member_path", reinterpret_cast<getter>(ItemsControl_get_DisplayMemberPath), reinterpret_cast<setter>(ItemsControl_put_DisplayMemberPath), nullptr, nullptr },
        { "group_style", reinterpret_cast<getter>(ItemsControl_get_GroupStyle), nullptr, nullptr, nullptr },
        { "is_grouping", reinterpret_cast<getter>(ItemsControl_get_IsGrouping), nullptr, nullptr, nullptr },
        { "item_container_generator", reinterpret_cast<getter>(ItemsControl_get_ItemContainerGenerator), nullptr, nullptr, nullptr },
        { "items", reinterpret_cast<getter>(ItemsControl_get_Items), nullptr, nullptr, nullptr },
        { "items_panel_root", reinterpret_cast<getter>(ItemsControl_get_ItemsPanelRoot), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsControl[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsControl) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsControl) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsControl) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsControl) },
        { },
    };

    static PyType_Spec type_spec_ItemsControl =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsControl",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsControl
    };

    static PyGetSetDef getset_ItemsControl_Static[] = {
        { "display_member_path_property", reinterpret_cast<getter>(ItemsControl_get_DisplayMemberPathProperty), nullptr, nullptr, nullptr },
        { "group_style_selector_property", reinterpret_cast<getter>(ItemsControl_get_GroupStyleSelectorProperty), nullptr, nullptr, nullptr },
        { "is_grouping_property", reinterpret_cast<getter>(ItemsControl_get_IsGroupingProperty), nullptr, nullptr, nullptr },
        { "item_container_style_property", reinterpret_cast<getter>(ItemsControl_get_ItemContainerStyleProperty), nullptr, nullptr, nullptr },
        { "item_container_style_selector_property", reinterpret_cast<getter>(ItemsControl_get_ItemContainerStyleSelectorProperty), nullptr, nullptr, nullptr },
        { "item_container_transitions_property", reinterpret_cast<getter>(ItemsControl_get_ItemContainerTransitionsProperty), nullptr, nullptr, nullptr },
        { "item_template_property", reinterpret_cast<getter>(ItemsControl_get_ItemTemplateProperty), nullptr, nullptr, nullptr },
        { "item_template_selector_property", reinterpret_cast<getter>(ItemsControl_get_ItemTemplateSelectorProperty), nullptr, nullptr, nullptr },
        { "items_panel_property", reinterpret_cast<getter>(ItemsControl_get_ItemsPanelProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(ItemsControl_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ItemsControl_Static[] = {
        { "get_items_owner", reinterpret_cast<PyCFunction>(ItemsControl_GetItemsOwner), METH_VARARGS, nullptr },
        { "items_control_from_item_container", reinterpret_cast<PyCFunction>(ItemsControl_ItemsControlFromItemContainer), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_ItemsControl_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ItemsControl_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ItemsControl_Static) },
        { }
    };

    static PyType_Spec type_spec_ItemsControl_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsControl_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ItemsControl_Static
    };

    // ----- ItemsPanelTemplate class --------------------

    static PyObject* _new_ItemsPanelTemplate(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::Microsoft::UI::Xaml::Controls::ItemsPanelTemplate 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_ItemsPanelTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPanelTemplate* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ItemsPanelTemplate(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsPanelTemplate>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsPanelTemplate(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsPanelTemplate>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsPanelTemplate[] = {
        { "_assign_array_", _assign_array_ItemsPanelTemplate, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsPanelTemplate), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsPanelTemplate[] = {
        { }
    };

    static PyType_Slot _type_slots_ItemsPanelTemplate[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsPanelTemplate) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsPanelTemplate) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsPanelTemplate) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsPanelTemplate) },
        { },
    };

    static PyType_Spec type_spec_ItemsPanelTemplate =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsPanelTemplate",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPanelTemplate),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsPanelTemplate
    };

    // ----- ItemsPickedEventArgs class --------------------

    static PyObject* _new_ItemsPickedEventArgs(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::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs 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_ItemsPickedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsPickedEventArgs_get_AddedItems(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPickedEventArgs", L"AddedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AddedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPickedEventArgs_get_RemovedItems(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPickedEventArgs", L"RemovedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RemovedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsPickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsPickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsPickedEventArgs[] = {
        { "_assign_array_", _assign_array_ItemsPickedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsPickedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsPickedEventArgs[] = {
        { "added_items", reinterpret_cast<getter>(ItemsPickedEventArgs_get_AddedItems), nullptr, nullptr, nullptr },
        { "removed_items", reinterpret_cast<getter>(ItemsPickedEventArgs_get_RemovedItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsPickedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsPickedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsPickedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsPickedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsPickedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemsPickedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsPickedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsPickedEventArgs
    };

    // ----- ItemsPresenter class --------------------

    static PyObject* _new_ItemsPresenter(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::Microsoft::UI::Xaml::Controls::ItemsPresenter 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_ItemsPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsPresenter_GetIrregularSnapPoints(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"GetIrregularSnapPoints", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Orientation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::SnapPointsAlignment>(args, 1);

                return py::convert(self->obj.GetIrregularSnapPoints(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_GetRegularSnapPoints(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"GetRegularSnapPoints", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Orientation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::SnapPointsAlignment>(args, 1);
                float param2 {  };

                auto return_value = self->obj.GetRegularSnapPoints(param0, param1, param2);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out2{ py::convert(param2) };
                if (!out2)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out2.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Padding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsPresenter_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.Padding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsPresenter_get_HeaderTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HeaderTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTransitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsPresenter_put_HeaderTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HeaderTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

            self->obj.HeaderTransitions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsPresenter_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsPresenter_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsPresenter_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsPresenter_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsPresenter_get_FooterTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"FooterTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FooterTransitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsPresenter_put_FooterTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"FooterTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

            self->obj.FooterTransitions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsPresenter_get_FooterTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"FooterTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FooterTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsPresenter_put_FooterTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"FooterTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.FooterTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsPresenter_get_Footer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"Footer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Footer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsPresenter_put_Footer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"Footer"))
        {
            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.Footer(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsPresenter_get_AreHorizontalSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"AreHorizontalSnapPointsRegular"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreHorizontalSnapPointsRegular());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_AreVerticalSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"AreVerticalSnapPointsRegular"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreVerticalSnapPointsRegular());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_FooterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"FooterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter::FooterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_FooterTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"FooterTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter::FooterTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_FooterTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"FooterTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter::FooterTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_HeaderTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HeaderTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter::HeaderTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_add_HorizontalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HorizontalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.HorizontalSnapPointsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_remove_HorizontalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"HorizontalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.HorizontalSnapPointsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_add_VerticalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"VerticalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.VerticalSnapPointsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsPresenter_remove_VerticalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsPresenter", L"VerticalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.VerticalSnapPointsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsPresenter[] = {
        { "get_irregular_snap_points", reinterpret_cast<PyCFunction>(ItemsPresenter_GetIrregularSnapPoints), METH_VARARGS, nullptr },
        { "get_regular_snap_points", reinterpret_cast<PyCFunction>(ItemsPresenter_GetRegularSnapPoints), METH_VARARGS, nullptr },
        { "add_horizontal_snap_points_changed", reinterpret_cast<PyCFunction>(ItemsPresenter_add_HorizontalSnapPointsChanged), METH_O, nullptr },
        { "remove_horizontal_snap_points_changed", reinterpret_cast<PyCFunction>(ItemsPresenter_remove_HorizontalSnapPointsChanged), METH_O, nullptr },
        { "add_vertical_snap_points_changed", reinterpret_cast<PyCFunction>(ItemsPresenter_add_VerticalSnapPointsChanged), METH_O, nullptr },
        { "remove_vertical_snap_points_changed", reinterpret_cast<PyCFunction>(ItemsPresenter_remove_VerticalSnapPointsChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_ItemsPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsPresenter[] = {
        { "padding", reinterpret_cast<getter>(ItemsPresenter_get_Padding), reinterpret_cast<setter>(ItemsPresenter_put_Padding), nullptr, nullptr },
        { "header_transitions", reinterpret_cast<getter>(ItemsPresenter_get_HeaderTransitions), reinterpret_cast<setter>(ItemsPresenter_put_HeaderTransitions), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(ItemsPresenter_get_HeaderTemplate), reinterpret_cast<setter>(ItemsPresenter_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(ItemsPresenter_get_Header), reinterpret_cast<setter>(ItemsPresenter_put_Header), nullptr, nullptr },
        { "footer_transitions", reinterpret_cast<getter>(ItemsPresenter_get_FooterTransitions), reinterpret_cast<setter>(ItemsPresenter_put_FooterTransitions), nullptr, nullptr },
        { "footer_template", reinterpret_cast<getter>(ItemsPresenter_get_FooterTemplate), reinterpret_cast<setter>(ItemsPresenter_put_FooterTemplate), nullptr, nullptr },
        { "footer", reinterpret_cast<getter>(ItemsPresenter_get_Footer), reinterpret_cast<setter>(ItemsPresenter_put_Footer), nullptr, nullptr },
        { "are_horizontal_snap_points_regular", reinterpret_cast<getter>(ItemsPresenter_get_AreHorizontalSnapPointsRegular), nullptr, nullptr, nullptr },
        { "are_vertical_snap_points_regular", reinterpret_cast<getter>(ItemsPresenter_get_AreVerticalSnapPointsRegular), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsPresenter) },
        { },
    };

    static PyType_Spec type_spec_ItemsPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsPresenter
    };

    static PyGetSetDef getset_ItemsPresenter_Static[] = {
        { "footer_property", reinterpret_cast<getter>(ItemsPresenter_get_FooterProperty), nullptr, nullptr, nullptr },
        { "footer_template_property", reinterpret_cast<getter>(ItemsPresenter_get_FooterTemplateProperty), nullptr, nullptr, nullptr },
        { "footer_transitions_property", reinterpret_cast<getter>(ItemsPresenter_get_FooterTransitionsProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(ItemsPresenter_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(ItemsPresenter_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "header_transitions_property", reinterpret_cast<getter>(ItemsPresenter_get_HeaderTransitionsProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(ItemsPresenter_get_PaddingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ItemsPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ItemsPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ItemsPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ItemsPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_ItemsPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ItemsPresenter_Static
    };

    // ----- ItemsRepeater class --------------------

    static PyObject* _new_ItemsRepeater(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::Microsoft::UI::Xaml::Controls::ItemsRepeater 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_ItemsRepeater(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsRepeater_GetElementIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"GetElementIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(self->obj.GetElementIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_GetOrCreateElement(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"GetOrCreateElement", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.GetOrCreateElement(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_TryGetElement(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"TryGetElement", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.TryGetElement(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_VerticalCacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"VerticalCacheLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalCacheLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeater_put_VerticalCacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"VerticalCacheLength"))
        {
            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<double>(arg);

            self->obj.VerticalCacheLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeater_get_Layout(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"Layout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Layout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeater_put_Layout(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"Layout"))
        {
            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::Microsoft::UI::Xaml::Controls::Layout>(arg);

            self->obj.Layout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeater_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeater_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeater_get_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeater_put_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemTemplate"))
        {
            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.ItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeater_get_HorizontalCacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"HorizontalCacheLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalCacheLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeater_put_HorizontalCacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"HorizontalCacheLength"))
        {
            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<double>(arg);

            self->obj.HorizontalCacheLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeater_get_Background(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"Background"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Background());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeater_put_Background(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"Background"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Background(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeater_get_ItemsSourceView(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemsSourceView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSourceView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_ItemTransitionProvider(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemTransitionProvider"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTransitionProvider());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeater_put_ItemTransitionProvider(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemTransitionProvider"))
        {
            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::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider>(arg);

            self->obj.ItemTransitionProvider(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeater_get_BackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"BackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater::BackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_HorizontalCacheLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"HorizontalCacheLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater::HorizontalCacheLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_ItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater::ItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_LayoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"LayoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater::LayoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_VerticalCacheLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"VerticalCacheLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater::VerticalCacheLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_get_ItemTransitionProviderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ItemTransitionProviderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater::ItemTransitionProviderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_add_ElementClearing(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ElementClearing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater, winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs>>(arg);

            return py::convert(self->obj.ElementClearing(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_remove_ElementClearing(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ElementClearing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ElementClearing(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_add_ElementIndexChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ElementIndexChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater, winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs>>(arg);

            return py::convert(self->obj.ElementIndexChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_remove_ElementIndexChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ElementIndexChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ElementIndexChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_add_ElementPrepared(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ElementPrepared"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater, winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs>>(arg);

            return py::convert(self->obj.ElementPrepared(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeater_remove_ElementPrepared(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeater", L"ElementPrepared"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ElementPrepared(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsRepeater(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsRepeater(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeater>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsRepeater[] = {
        { "get_element_index", reinterpret_cast<PyCFunction>(ItemsRepeater_GetElementIndex), METH_VARARGS, nullptr },
        { "get_or_create_element", reinterpret_cast<PyCFunction>(ItemsRepeater_GetOrCreateElement), METH_VARARGS, nullptr },
        { "try_get_element", reinterpret_cast<PyCFunction>(ItemsRepeater_TryGetElement), METH_VARARGS, nullptr },
        { "add_element_clearing", reinterpret_cast<PyCFunction>(ItemsRepeater_add_ElementClearing), METH_O, nullptr },
        { "remove_element_clearing", reinterpret_cast<PyCFunction>(ItemsRepeater_remove_ElementClearing), METH_O, nullptr },
        { "add_element_index_changed", reinterpret_cast<PyCFunction>(ItemsRepeater_add_ElementIndexChanged), METH_O, nullptr },
        { "remove_element_index_changed", reinterpret_cast<PyCFunction>(ItemsRepeater_remove_ElementIndexChanged), METH_O, nullptr },
        { "add_element_prepared", reinterpret_cast<PyCFunction>(ItemsRepeater_add_ElementPrepared), METH_O, nullptr },
        { "remove_element_prepared", reinterpret_cast<PyCFunction>(ItemsRepeater_remove_ElementPrepared), METH_O, nullptr },
        { "_assign_array_", _assign_array_ItemsRepeater, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsRepeater), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsRepeater[] = {
        { "vertical_cache_length", reinterpret_cast<getter>(ItemsRepeater_get_VerticalCacheLength), reinterpret_cast<setter>(ItemsRepeater_put_VerticalCacheLength), nullptr, nullptr },
        { "layout", reinterpret_cast<getter>(ItemsRepeater_get_Layout), reinterpret_cast<setter>(ItemsRepeater_put_Layout), nullptr, nullptr },
        { "items_source", reinterpret_cast<getter>(ItemsRepeater_get_ItemsSource), reinterpret_cast<setter>(ItemsRepeater_put_ItemsSource), nullptr, nullptr },
        { "item_template", reinterpret_cast<getter>(ItemsRepeater_get_ItemTemplate), reinterpret_cast<setter>(ItemsRepeater_put_ItemTemplate), nullptr, nullptr },
        { "horizontal_cache_length", reinterpret_cast<getter>(ItemsRepeater_get_HorizontalCacheLength), reinterpret_cast<setter>(ItemsRepeater_put_HorizontalCacheLength), nullptr, nullptr },
        { "background", reinterpret_cast<getter>(ItemsRepeater_get_Background), reinterpret_cast<setter>(ItemsRepeater_put_Background), nullptr, nullptr },
        { "items_source_view", reinterpret_cast<getter>(ItemsRepeater_get_ItemsSourceView), nullptr, nullptr, nullptr },
        { "item_transition_provider", reinterpret_cast<getter>(ItemsRepeater_get_ItemTransitionProvider), reinterpret_cast<setter>(ItemsRepeater_put_ItemTransitionProvider), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsRepeater[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsRepeater) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsRepeater) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsRepeater) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsRepeater) },
        { },
    };

    static PyType_Spec type_spec_ItemsRepeater =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsRepeater",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeater),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsRepeater
    };

    static PyGetSetDef getset_ItemsRepeater_Static[] = {
        { "background_property", reinterpret_cast<getter>(ItemsRepeater_get_BackgroundProperty), nullptr, nullptr, nullptr },
        { "horizontal_cache_length_property", reinterpret_cast<getter>(ItemsRepeater_get_HorizontalCacheLengthProperty), nullptr, nullptr, nullptr },
        { "item_template_property", reinterpret_cast<getter>(ItemsRepeater_get_ItemTemplateProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(ItemsRepeater_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { "layout_property", reinterpret_cast<getter>(ItemsRepeater_get_LayoutProperty), nullptr, nullptr, nullptr },
        { "vertical_cache_length_property", reinterpret_cast<getter>(ItemsRepeater_get_VerticalCacheLengthProperty), nullptr, nullptr, nullptr },
        { "item_transition_provider_property", reinterpret_cast<getter>(ItemsRepeater_get_ItemTransitionProviderProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ItemsRepeater_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ItemsRepeater_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ItemsRepeater_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ItemsRepeater_Static) },
        { }
    };

    static PyType_Spec type_spec_ItemsRepeater_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsRepeater_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ItemsRepeater_Static
    };

    // ----- ItemsRepeaterElementClearingEventArgs class --------------------

    static PyObject* _new_ItemsRepeaterElementClearingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemsRepeaterElementClearingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsRepeaterElementClearingEventArgs_get_Element(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterElementClearingEventArgs", L"Element"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Element());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsRepeaterElementClearingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsRepeaterElementClearingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsRepeaterElementClearingEventArgs[] = {
        { "_assign_array_", _assign_array_ItemsRepeaterElementClearingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsRepeaterElementClearingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsRepeaterElementClearingEventArgs[] = {
        { "element", reinterpret_cast<getter>(ItemsRepeaterElementClearingEventArgs_get_Element), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsRepeaterElementClearingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsRepeaterElementClearingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsRepeaterElementClearingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsRepeaterElementClearingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsRepeaterElementClearingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemsRepeaterElementClearingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsRepeaterElementClearingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementClearingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsRepeaterElementClearingEventArgs
    };

    // ----- ItemsRepeaterElementIndexChangedEventArgs class --------------------

    static PyObject* _new_ItemsRepeaterElementIndexChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemsRepeaterElementIndexChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsRepeaterElementIndexChangedEventArgs_get_Element(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterElementIndexChangedEventArgs", L"Element"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Element());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeaterElementIndexChangedEventArgs_get_NewIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterElementIndexChangedEventArgs", L"NewIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeaterElementIndexChangedEventArgs_get_OldIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterElementIndexChangedEventArgs", L"OldIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OldIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsRepeaterElementIndexChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsRepeaterElementIndexChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsRepeaterElementIndexChangedEventArgs[] = {
        { "_assign_array_", _assign_array_ItemsRepeaterElementIndexChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsRepeaterElementIndexChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsRepeaterElementIndexChangedEventArgs[] = {
        { "element", reinterpret_cast<getter>(ItemsRepeaterElementIndexChangedEventArgs_get_Element), nullptr, nullptr, nullptr },
        { "new_index", reinterpret_cast<getter>(ItemsRepeaterElementIndexChangedEventArgs_get_NewIndex), nullptr, nullptr, nullptr },
        { "old_index", reinterpret_cast<getter>(ItemsRepeaterElementIndexChangedEventArgs_get_OldIndex), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsRepeaterElementIndexChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsRepeaterElementIndexChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsRepeaterElementIndexChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsRepeaterElementIndexChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsRepeaterElementIndexChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemsRepeaterElementIndexChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsRepeaterElementIndexChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementIndexChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsRepeaterElementIndexChangedEventArgs
    };

    // ----- ItemsRepeaterElementPreparedEventArgs class --------------------

    static PyObject* _new_ItemsRepeaterElementPreparedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemsRepeaterElementPreparedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsRepeaterElementPreparedEventArgs_get_Element(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterElementPreparedEventArgs", L"Element"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Element());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsRepeaterElementPreparedEventArgs_get_Index(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterElementPreparedEventArgs", L"Index"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Index());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsRepeaterElementPreparedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsRepeaterElementPreparedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsRepeaterElementPreparedEventArgs[] = {
        { "_assign_array_", _assign_array_ItemsRepeaterElementPreparedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsRepeaterElementPreparedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsRepeaterElementPreparedEventArgs[] = {
        { "element", reinterpret_cast<getter>(ItemsRepeaterElementPreparedEventArgs_get_Element), nullptr, nullptr, nullptr },
        { "index", reinterpret_cast<getter>(ItemsRepeaterElementPreparedEventArgs_get_Index), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsRepeaterElementPreparedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsRepeaterElementPreparedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsRepeaterElementPreparedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsRepeaterElementPreparedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsRepeaterElementPreparedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemsRepeaterElementPreparedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsRepeaterElementPreparedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterElementPreparedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsRepeaterElementPreparedEventArgs
    };

    // ----- ItemsRepeaterScrollHost class --------------------

    static PyObject* _new_ItemsRepeaterScrollHost(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::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost 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_ItemsRepeaterScrollHost(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsRepeaterScrollHost_get_VerticalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost", L"VerticalAnchorRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalAnchorRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeaterScrollHost_put_VerticalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost", L"VerticalAnchorRatio"))
        {
            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<double>(arg);

            self->obj.VerticalAnchorRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeaterScrollHost_get_ScrollViewer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost", L"ScrollViewer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollViewer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeaterScrollHost_put_ScrollViewer(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost", L"ScrollViewer"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollViewer>(arg);

            self->obj.ScrollViewer(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeaterScrollHost_get_HorizontalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost", L"HorizontalAnchorRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalAnchorRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsRepeaterScrollHost_put_HorizontalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost", L"HorizontalAnchorRatio"))
        {
            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<double>(arg);

            self->obj.HorizontalAnchorRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsRepeaterScrollHost_get_CurrentAnchor(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost", L"CurrentAnchor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CurrentAnchor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsRepeaterScrollHost(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsRepeaterScrollHost(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsRepeaterScrollHost[] = {
        { "_assign_array_", _assign_array_ItemsRepeaterScrollHost, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsRepeaterScrollHost), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsRepeaterScrollHost[] = {
        { "vertical_anchor_ratio", reinterpret_cast<getter>(ItemsRepeaterScrollHost_get_VerticalAnchorRatio), reinterpret_cast<setter>(ItemsRepeaterScrollHost_put_VerticalAnchorRatio), nullptr, nullptr },
        { "scroll_viewer", reinterpret_cast<getter>(ItemsRepeaterScrollHost_get_ScrollViewer), reinterpret_cast<setter>(ItemsRepeaterScrollHost_put_ScrollViewer), nullptr, nullptr },
        { "horizontal_anchor_ratio", reinterpret_cast<getter>(ItemsRepeaterScrollHost_get_HorizontalAnchorRatio), reinterpret_cast<setter>(ItemsRepeaterScrollHost_put_HorizontalAnchorRatio), nullptr, nullptr },
        { "current_anchor", reinterpret_cast<getter>(ItemsRepeaterScrollHost_get_CurrentAnchor), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsRepeaterScrollHost[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsRepeaterScrollHost) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsRepeaterScrollHost) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsRepeaterScrollHost) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsRepeaterScrollHost) },
        { },
    };

    static PyType_Spec type_spec_ItemsRepeaterScrollHost =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsRepeaterScrollHost",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsRepeaterScrollHost),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsRepeaterScrollHost
    };

    // ----- ItemsSourceView class --------------------

    static PyObject* _new_ItemsSourceView(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                winrt::Microsoft::UI::Xaml::Controls::ItemsSourceView instance{ param0 };
                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_ItemsSourceView(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsSourceView_GetAt(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"GetAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_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* ItemsSourceView_IndexFromKey(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"IndexFromKey", 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.IndexFromKey(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsSourceView_IndexOf(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.IndexOf(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsSourceView_KeyFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"KeyFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.KeyFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsSourceView_get_Count(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"Count"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Count());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsSourceView_get_HasKeyIndexMapping(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"HasKeyIndexMapping"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasKeyIndexMapping());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsSourceView_add_CollectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"CollectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Interop::NotifyCollectionChangedEventHandler>(arg);

            return py::convert(self->obj.CollectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsSourceView_remove_CollectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsSourceView", L"CollectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CollectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsSourceView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsSourceView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsSourceView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsSourceView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsSourceView[] = {
        { "get_at", reinterpret_cast<PyCFunction>(ItemsSourceView_GetAt), METH_VARARGS, nullptr },
        { "index_from_key", reinterpret_cast<PyCFunction>(ItemsSourceView_IndexFromKey), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(ItemsSourceView_IndexOf), METH_VARARGS, nullptr },
        { "key_from_index", reinterpret_cast<PyCFunction>(ItemsSourceView_KeyFromIndex), METH_VARARGS, nullptr },
        { "add_collection_changed", reinterpret_cast<PyCFunction>(ItemsSourceView_add_CollectionChanged), METH_O, nullptr },
        { "remove_collection_changed", reinterpret_cast<PyCFunction>(ItemsSourceView_remove_CollectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_ItemsSourceView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsSourceView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsSourceView[] = {
        { "count", reinterpret_cast<getter>(ItemsSourceView_get_Count), nullptr, nullptr, nullptr },
        { "has_key_index_mapping", reinterpret_cast<getter>(ItemsSourceView_get_HasKeyIndexMapping), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsSourceView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsSourceView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsSourceView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsSourceView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsSourceView) },
        { },
    };

    static PyType_Spec type_spec_ItemsSourceView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsSourceView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsSourceView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsSourceView
    };

    // ----- ItemsStackPanel class --------------------

    static PyObject* _new_ItemsStackPanel(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::Microsoft::UI::Xaml::Controls::ItemsStackPanel 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_ItemsStackPanel(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsStackPanel_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsStackPanel_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsStackPanel_get_ItemsUpdatingScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"ItemsUpdatingScrollMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsUpdatingScrollMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsStackPanel_put_ItemsUpdatingScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"ItemsUpdatingScrollMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ItemsUpdatingScrollMode>(arg);

            self->obj.ItemsUpdatingScrollMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsStackPanel_get_GroupPadding(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"GroupPadding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupPadding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsStackPanel_put_GroupPadding(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"GroupPadding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.GroupPadding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsStackPanel_get_GroupHeaderPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"GroupHeaderPlacement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupHeaderPlacement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsStackPanel_put_GroupHeaderPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"GroupHeaderPlacement"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::GroupHeaderPlacement>(arg);

            self->obj.GroupHeaderPlacement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsStackPanel_get_CacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"CacheLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CacheLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsStackPanel_put_CacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"CacheLength"))
        {
            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<double>(arg);

            self->obj.CacheLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsStackPanel_get_AreStickyGroupHeadersEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"AreStickyGroupHeadersEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreStickyGroupHeadersEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsStackPanel_put_AreStickyGroupHeadersEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"AreStickyGroupHeadersEnabled"))
        {
            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.AreStickyGroupHeadersEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsStackPanel_get_FirstCacheIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"FirstCacheIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FirstCacheIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_FirstVisibleIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"FirstVisibleIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FirstVisibleIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_LastCacheIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"LastCacheIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LastCacheIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_LastVisibleIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"LastVisibleIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LastVisibleIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_ScrollingDirection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"ScrollingDirection"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollingDirection());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_AreStickyGroupHeadersEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"AreStickyGroupHeadersEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsStackPanel::AreStickyGroupHeadersEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_CacheLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"CacheLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsStackPanel::CacheLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_GroupHeaderPlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"GroupHeaderPlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsStackPanel::GroupHeaderPlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_GroupPaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"GroupPaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsStackPanel::GroupPaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsStackPanel_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsStackPanel", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsStackPanel::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsStackPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsStackPanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsStackPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsStackPanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsStackPanel[] = {
        { "_assign_array_", _assign_array_ItemsStackPanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsStackPanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsStackPanel[] = {
        { "orientation", reinterpret_cast<getter>(ItemsStackPanel_get_Orientation), reinterpret_cast<setter>(ItemsStackPanel_put_Orientation), nullptr, nullptr },
        { "items_updating_scroll_mode", reinterpret_cast<getter>(ItemsStackPanel_get_ItemsUpdatingScrollMode), reinterpret_cast<setter>(ItemsStackPanel_put_ItemsUpdatingScrollMode), nullptr, nullptr },
        { "group_padding", reinterpret_cast<getter>(ItemsStackPanel_get_GroupPadding), reinterpret_cast<setter>(ItemsStackPanel_put_GroupPadding), nullptr, nullptr },
        { "group_header_placement", reinterpret_cast<getter>(ItemsStackPanel_get_GroupHeaderPlacement), reinterpret_cast<setter>(ItemsStackPanel_put_GroupHeaderPlacement), nullptr, nullptr },
        { "cache_length", reinterpret_cast<getter>(ItemsStackPanel_get_CacheLength), reinterpret_cast<setter>(ItemsStackPanel_put_CacheLength), nullptr, nullptr },
        { "are_sticky_group_headers_enabled", reinterpret_cast<getter>(ItemsStackPanel_get_AreStickyGroupHeadersEnabled), reinterpret_cast<setter>(ItemsStackPanel_put_AreStickyGroupHeadersEnabled), nullptr, nullptr },
        { "first_cache_index", reinterpret_cast<getter>(ItemsStackPanel_get_FirstCacheIndex), nullptr, nullptr, nullptr },
        { "first_visible_index", reinterpret_cast<getter>(ItemsStackPanel_get_FirstVisibleIndex), nullptr, nullptr, nullptr },
        { "last_cache_index", reinterpret_cast<getter>(ItemsStackPanel_get_LastCacheIndex), nullptr, nullptr, nullptr },
        { "last_visible_index", reinterpret_cast<getter>(ItemsStackPanel_get_LastVisibleIndex), nullptr, nullptr, nullptr },
        { "scrolling_direction", reinterpret_cast<getter>(ItemsStackPanel_get_ScrollingDirection), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsStackPanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsStackPanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsStackPanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsStackPanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsStackPanel) },
        { },
    };

    static PyType_Spec type_spec_ItemsStackPanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsStackPanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsStackPanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsStackPanel
    };

    static PyGetSetDef getset_ItemsStackPanel_Static[] = {
        { "are_sticky_group_headers_enabled_property", reinterpret_cast<getter>(ItemsStackPanel_get_AreStickyGroupHeadersEnabledProperty), nullptr, nullptr, nullptr },
        { "cache_length_property", reinterpret_cast<getter>(ItemsStackPanel_get_CacheLengthProperty), nullptr, nullptr, nullptr },
        { "group_header_placement_property", reinterpret_cast<getter>(ItemsStackPanel_get_GroupHeaderPlacementProperty), nullptr, nullptr, nullptr },
        { "group_padding_property", reinterpret_cast<getter>(ItemsStackPanel_get_GroupPaddingProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(ItemsStackPanel_get_OrientationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ItemsStackPanel_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ItemsStackPanel_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ItemsStackPanel_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ItemsStackPanel_Static) },
        { }
    };

    static PyType_Spec type_spec_ItemsStackPanel_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsStackPanel_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ItemsStackPanel_Static
    };

    // ----- ItemsView class --------------------

    static PyObject* _new_ItemsView(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::Microsoft::UI::Xaml::Controls::ItemsView 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_ItemsView(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsView_Deselect(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"Deselect", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                self->obj.Deselect(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_DeselectAll(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"DeselectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.DeselectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_InvertSelection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"InvertSelection", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.InvertSelection();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_IsSelected(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"IsSelected", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.IsSelected(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_Select(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"Select", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                self->obj.Select(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_StartBringItemIntoView(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"StartBringItemIntoView", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::BringIntoViewOptions>(args, 1);

                self->obj.StartBringItemIntoView(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_TryGetItemIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"TryGetItemIndex", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);
                int32_t param2 {  };

                auto return_value = self->obj.TryGetItemIndex(param0, param1, param2);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out2{ py::convert(param2) };
                if (!out2)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out2.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_VerticalScrollController(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"VerticalScrollController"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalScrollController());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsView_put_VerticalScrollController(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"VerticalScrollController"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::IScrollController>(arg);

            self->obj.VerticalScrollController(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsView_get_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsView_put_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectionMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ItemsViewSelectionMode>(arg);

            self->obj.SelectionMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsView_get_Layout(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"Layout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Layout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsView_put_Layout(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"Layout"))
        {
            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::Microsoft::UI::Xaml::Controls::Layout>(arg);

            self->obj.Layout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsView_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsView_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsView_get_ItemTransitionProvider(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemTransitionProvider"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTransitionProvider());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsView_put_ItemTransitionProvider(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemTransitionProvider"))
        {
            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::Microsoft::UI::Xaml::Controls::ItemCollectionTransitionProvider>(arg);

            self->obj.ItemTransitionProvider(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsView_get_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsView_put_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemTemplate"))
        {
            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::Microsoft::UI::Xaml::IElementFactory>(arg);

            self->obj.ItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsView_get_IsItemInvokedEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"IsItemInvokedEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsItemInvokedEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsView_put_IsItemInvokedEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"IsItemInvokedEnabled"))
        {
            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.IsItemInvokedEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsView_get_CurrentItemIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"CurrentItemIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CurrentItemIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_ScrollView(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ScrollView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_SelectedItems(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_CurrentItemIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"CurrentItemIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::CurrentItemIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_IsItemInvokedEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"IsItemInvokedEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::IsItemInvokedEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_ItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::ItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_ItemTransitionProviderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemTransitionProviderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::ItemTransitionProviderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_LayoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"LayoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::LayoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_ScrollViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ScrollViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::ScrollViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_SelectionModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectionModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::SelectionModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_get_VerticalScrollControllerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"VerticalScrollControllerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsView::VerticalScrollControllerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_add_ItemInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ItemsView, winrt::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs>>(arg);

            return py::convert(self->obj.ItemInvoked(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_remove_ItemInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"ItemInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemInvoked(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ItemsView, winrt::Microsoft::UI::Xaml::Controls::ItemsViewSelectionChangedEventArgs>>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsView_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ItemsView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsView[] = {
        { "deselect", reinterpret_cast<PyCFunction>(ItemsView_Deselect), METH_VARARGS, nullptr },
        { "deselect_all", reinterpret_cast<PyCFunction>(ItemsView_DeselectAll), METH_VARARGS, nullptr },
        { "invert_selection", reinterpret_cast<PyCFunction>(ItemsView_InvertSelection), METH_VARARGS, nullptr },
        { "is_selected", reinterpret_cast<PyCFunction>(ItemsView_IsSelected), METH_VARARGS, nullptr },
        { "select", reinterpret_cast<PyCFunction>(ItemsView_Select), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(ItemsView_SelectAll), METH_VARARGS, nullptr },
        { "start_bring_item_into_view", reinterpret_cast<PyCFunction>(ItemsView_StartBringItemIntoView), METH_VARARGS, nullptr },
        { "try_get_item_index", reinterpret_cast<PyCFunction>(ItemsView_TryGetItemIndex), METH_VARARGS, nullptr },
        { "add_item_invoked", reinterpret_cast<PyCFunction>(ItemsView_add_ItemInvoked), METH_O, nullptr },
        { "remove_item_invoked", reinterpret_cast<PyCFunction>(ItemsView_remove_ItemInvoked), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(ItemsView_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(ItemsView_remove_SelectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_ItemsView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsView[] = {
        { "vertical_scroll_controller", reinterpret_cast<getter>(ItemsView_get_VerticalScrollController), reinterpret_cast<setter>(ItemsView_put_VerticalScrollController), nullptr, nullptr },
        { "selection_mode", reinterpret_cast<getter>(ItemsView_get_SelectionMode), reinterpret_cast<setter>(ItemsView_put_SelectionMode), nullptr, nullptr },
        { "layout", reinterpret_cast<getter>(ItemsView_get_Layout), reinterpret_cast<setter>(ItemsView_put_Layout), nullptr, nullptr },
        { "items_source", reinterpret_cast<getter>(ItemsView_get_ItemsSource), reinterpret_cast<setter>(ItemsView_put_ItemsSource), nullptr, nullptr },
        { "item_transition_provider", reinterpret_cast<getter>(ItemsView_get_ItemTransitionProvider), reinterpret_cast<setter>(ItemsView_put_ItemTransitionProvider), nullptr, nullptr },
        { "item_template", reinterpret_cast<getter>(ItemsView_get_ItemTemplate), reinterpret_cast<setter>(ItemsView_put_ItemTemplate), nullptr, nullptr },
        { "is_item_invoked_enabled", reinterpret_cast<getter>(ItemsView_get_IsItemInvokedEnabled), reinterpret_cast<setter>(ItemsView_put_IsItemInvokedEnabled), nullptr, nullptr },
        { "current_item_index", reinterpret_cast<getter>(ItemsView_get_CurrentItemIndex), nullptr, nullptr, nullptr },
        { "scroll_view", reinterpret_cast<getter>(ItemsView_get_ScrollView), nullptr, nullptr, nullptr },
        { "selected_item", reinterpret_cast<getter>(ItemsView_get_SelectedItem), nullptr, nullptr, nullptr },
        { "selected_items", reinterpret_cast<getter>(ItemsView_get_SelectedItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsView) },
        { },
    };

    static PyType_Spec type_spec_ItemsView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsView
    };

    static PyGetSetDef getset_ItemsView_Static[] = {
        { "current_item_index_property", reinterpret_cast<getter>(ItemsView_get_CurrentItemIndexProperty), nullptr, nullptr, nullptr },
        { "is_item_invoked_enabled_property", reinterpret_cast<getter>(ItemsView_get_IsItemInvokedEnabledProperty), nullptr, nullptr, nullptr },
        { "item_template_property", reinterpret_cast<getter>(ItemsView_get_ItemTemplateProperty), nullptr, nullptr, nullptr },
        { "item_transition_provider_property", reinterpret_cast<getter>(ItemsView_get_ItemTransitionProviderProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(ItemsView_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { "layout_property", reinterpret_cast<getter>(ItemsView_get_LayoutProperty), nullptr, nullptr, nullptr },
        { "scroll_view_property", reinterpret_cast<getter>(ItemsView_get_ScrollViewProperty), nullptr, nullptr, nullptr },
        { "selected_item_property", reinterpret_cast<getter>(ItemsView_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { "selection_mode_property", reinterpret_cast<getter>(ItemsView_get_SelectionModeProperty), nullptr, nullptr, nullptr },
        { "vertical_scroll_controller_property", reinterpret_cast<getter>(ItemsView_get_VerticalScrollControllerProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ItemsView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ItemsView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ItemsView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ItemsView_Static) },
        { }
    };

    static PyType_Spec type_spec_ItemsView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ItemsView_Static
    };

    // ----- ItemsViewItemInvokedEventArgs class --------------------

    static PyObject* _new_ItemsViewItemInvokedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemsViewItemInvokedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsViewItemInvokedEventArgs_get_InvokedItem(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsViewItemInvokedEventArgs", L"InvokedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InvokedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsViewItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsViewItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsViewItemInvokedEventArgs[] = {
        { "_assign_array_", _assign_array_ItemsViewItemInvokedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsViewItemInvokedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsViewItemInvokedEventArgs[] = {
        { "invoked_item", reinterpret_cast<getter>(ItemsViewItemInvokedEventArgs_get_InvokedItem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsViewItemInvokedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsViewItemInvokedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsViewItemInvokedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsViewItemInvokedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsViewItemInvokedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemsViewItemInvokedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsViewItemInvokedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsViewItemInvokedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsViewItemInvokedEventArgs
    };

    // ----- ItemsViewSelectionChangedEventArgs class --------------------

    static PyObject* _new_ItemsViewSelectionChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsViewSelectionChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ItemsViewSelectionChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ItemsViewSelectionChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsViewSelectionChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ItemsViewSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsViewSelectionChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsViewSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsViewSelectionChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsViewSelectionChangedEventArgs[] = {
        { "_assign_array_", _assign_array_ItemsViewSelectionChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsViewSelectionChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsViewSelectionChangedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_ItemsViewSelectionChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsViewSelectionChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsViewSelectionChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsViewSelectionChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsViewSelectionChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ItemsViewSelectionChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsViewSelectionChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsViewSelectionChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsViewSelectionChangedEventArgs
    };

    // ----- ItemsWrapGrid class --------------------

    static PyObject* _new_ItemsWrapGrid(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::Microsoft::UI::Xaml::Controls::ItemsWrapGrid 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_ItemsWrapGrid(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ItemsWrapGrid_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"MaximumRowsOrColumns"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaximumRowsOrColumns());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"MaximumRowsOrColumns"))
        {
            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<int32_t>(arg);

            self->obj.MaximumRowsOrColumns(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_ItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"ItemWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_ItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"ItemWidth"))
        {
            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<double>(arg);

            self->obj.ItemWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_ItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"ItemHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_ItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"ItemHeight"))
        {
            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<double>(arg);

            self->obj.ItemHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_GroupPadding(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"GroupPadding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupPadding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_GroupPadding(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"GroupPadding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.GroupPadding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_GroupHeaderPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"GroupHeaderPlacement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupHeaderPlacement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_GroupHeaderPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"GroupHeaderPlacement"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::GroupHeaderPlacement>(arg);

            self->obj.GroupHeaderPlacement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_CacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"CacheLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CacheLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_CacheLength(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"CacheLength"))
        {
            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<double>(arg);

            self->obj.CacheLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_AreStickyGroupHeadersEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"AreStickyGroupHeadersEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreStickyGroupHeadersEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ItemsWrapGrid_put_AreStickyGroupHeadersEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"AreStickyGroupHeadersEnabled"))
        {
            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.AreStickyGroupHeadersEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ItemsWrapGrid_get_FirstCacheIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"FirstCacheIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FirstCacheIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_FirstVisibleIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"FirstVisibleIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FirstVisibleIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_LastCacheIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"LastCacheIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LastCacheIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_LastVisibleIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"LastVisibleIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LastVisibleIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_ScrollingDirection(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"ScrollingDirection"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollingDirection());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_AreStickyGroupHeadersEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"AreStickyGroupHeadersEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::AreStickyGroupHeadersEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_CacheLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"CacheLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::CacheLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_GroupHeaderPlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"GroupHeaderPlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::GroupHeaderPlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_GroupPaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"GroupPaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::GroupPaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_ItemHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"ItemHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::ItemHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_ItemWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"ItemWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::ItemWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_MaximumRowsOrColumnsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"MaximumRowsOrColumnsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::MaximumRowsOrColumnsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ItemsWrapGrid_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ItemsWrapGrid", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ItemsWrapGrid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ItemsWrapGrid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ItemsWrapGrid>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ItemsWrapGrid[] = {
        { "_assign_array_", _assign_array_ItemsWrapGrid, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ItemsWrapGrid), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ItemsWrapGrid[] = {
        { "orientation", reinterpret_cast<getter>(ItemsWrapGrid_get_Orientation), reinterpret_cast<setter>(ItemsWrapGrid_put_Orientation), nullptr, nullptr },
        { "maximum_rows_or_columns", reinterpret_cast<getter>(ItemsWrapGrid_get_MaximumRowsOrColumns), reinterpret_cast<setter>(ItemsWrapGrid_put_MaximumRowsOrColumns), nullptr, nullptr },
        { "item_width", reinterpret_cast<getter>(ItemsWrapGrid_get_ItemWidth), reinterpret_cast<setter>(ItemsWrapGrid_put_ItemWidth), nullptr, nullptr },
        { "item_height", reinterpret_cast<getter>(ItemsWrapGrid_get_ItemHeight), reinterpret_cast<setter>(ItemsWrapGrid_put_ItemHeight), nullptr, nullptr },
        { "group_padding", reinterpret_cast<getter>(ItemsWrapGrid_get_GroupPadding), reinterpret_cast<setter>(ItemsWrapGrid_put_GroupPadding), nullptr, nullptr },
        { "group_header_placement", reinterpret_cast<getter>(ItemsWrapGrid_get_GroupHeaderPlacement), reinterpret_cast<setter>(ItemsWrapGrid_put_GroupHeaderPlacement), nullptr, nullptr },
        { "cache_length", reinterpret_cast<getter>(ItemsWrapGrid_get_CacheLength), reinterpret_cast<setter>(ItemsWrapGrid_put_CacheLength), nullptr, nullptr },
        { "are_sticky_group_headers_enabled", reinterpret_cast<getter>(ItemsWrapGrid_get_AreStickyGroupHeadersEnabled), reinterpret_cast<setter>(ItemsWrapGrid_put_AreStickyGroupHeadersEnabled), nullptr, nullptr },
        { "first_cache_index", reinterpret_cast<getter>(ItemsWrapGrid_get_FirstCacheIndex), nullptr, nullptr, nullptr },
        { "first_visible_index", reinterpret_cast<getter>(ItemsWrapGrid_get_FirstVisibleIndex), nullptr, nullptr, nullptr },
        { "last_cache_index", reinterpret_cast<getter>(ItemsWrapGrid_get_LastCacheIndex), nullptr, nullptr, nullptr },
        { "last_visible_index", reinterpret_cast<getter>(ItemsWrapGrid_get_LastVisibleIndex), nullptr, nullptr, nullptr },
        { "scrolling_direction", reinterpret_cast<getter>(ItemsWrapGrid_get_ScrollingDirection), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ItemsWrapGrid[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ItemsWrapGrid) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ItemsWrapGrid) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ItemsWrapGrid) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ItemsWrapGrid) },
        { },
    };

    static PyType_Spec type_spec_ItemsWrapGrid =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsWrapGrid",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ItemsWrapGrid),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ItemsWrapGrid
    };

    static PyGetSetDef getset_ItemsWrapGrid_Static[] = {
        { "are_sticky_group_headers_enabled_property", reinterpret_cast<getter>(ItemsWrapGrid_get_AreStickyGroupHeadersEnabledProperty), nullptr, nullptr, nullptr },
        { "cache_length_property", reinterpret_cast<getter>(ItemsWrapGrid_get_CacheLengthProperty), nullptr, nullptr, nullptr },
        { "group_header_placement_property", reinterpret_cast<getter>(ItemsWrapGrid_get_GroupHeaderPlacementProperty), nullptr, nullptr, nullptr },
        { "group_padding_property", reinterpret_cast<getter>(ItemsWrapGrid_get_GroupPaddingProperty), nullptr, nullptr, nullptr },
        { "item_height_property", reinterpret_cast<getter>(ItemsWrapGrid_get_ItemHeightProperty), nullptr, nullptr, nullptr },
        { "item_width_property", reinterpret_cast<getter>(ItemsWrapGrid_get_ItemWidthProperty), nullptr, nullptr, nullptr },
        { "maximum_rows_or_columns_property", reinterpret_cast<getter>(ItemsWrapGrid_get_MaximumRowsOrColumnsProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(ItemsWrapGrid_get_OrientationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ItemsWrapGrid_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ItemsWrapGrid_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ItemsWrapGrid_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ItemsWrapGrid_Static) },
        { }
    };

    static PyType_Spec type_spec_ItemsWrapGrid_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ItemsWrapGrid_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ItemsWrapGrid_Static
    };

    // ----- Layout class --------------------

    static PyObject* _new_Layout(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::Layout>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::Layout>::type_name);
        return nullptr;
    }

    static void _dealloc_Layout(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Layout_Arrange(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"Arrange", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Size>(args, 1);

                return py::convert(self->obj.Arrange(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Layout_InitializeForContext(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"InitializeForContext", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>(args, 0);

                self->obj.InitializeForContext(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Layout_Measure(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"Measure", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Size>(args, 1);

                return py::convert(self->obj.Measure(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Layout_UninitializeForContext(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"UninitializeForContext", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>(args, 0);

                self->obj.UninitializeForContext(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Layout_get_IndexBasedLayoutOrientation(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"IndexBasedLayoutOrientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IndexBasedLayoutOrientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Layout_add_ArrangeInvalidated(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"ArrangeInvalidated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Layout, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ArrangeInvalidated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Layout_remove_ArrangeInvalidated(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"ArrangeInvalidated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ArrangeInvalidated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Layout_add_MeasureInvalidated(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"MeasureInvalidated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Layout, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.MeasureInvalidated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Layout_remove_MeasureInvalidated(py::wrapper::Microsoft::UI::Xaml::Controls::Layout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Layout", L"MeasureInvalidated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.MeasureInvalidated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Layout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Layout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Layout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Layout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Layout[] = {
        { "arrange", reinterpret_cast<PyCFunction>(Layout_Arrange), METH_VARARGS, nullptr },
        { "initialize_for_context", reinterpret_cast<PyCFunction>(Layout_InitializeForContext), METH_VARARGS, nullptr },
        { "measure", reinterpret_cast<PyCFunction>(Layout_Measure), METH_VARARGS, nullptr },
        { "uninitialize_for_context", reinterpret_cast<PyCFunction>(Layout_UninitializeForContext), METH_VARARGS, nullptr },
        { "add_arrange_invalidated", reinterpret_cast<PyCFunction>(Layout_add_ArrangeInvalidated), METH_O, nullptr },
        { "remove_arrange_invalidated", reinterpret_cast<PyCFunction>(Layout_remove_ArrangeInvalidated), METH_O, nullptr },
        { "add_measure_invalidated", reinterpret_cast<PyCFunction>(Layout_add_MeasureInvalidated), METH_O, nullptr },
        { "remove_measure_invalidated", reinterpret_cast<PyCFunction>(Layout_remove_MeasureInvalidated), METH_O, nullptr },
        { "_assign_array_", _assign_array_Layout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Layout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Layout[] = {
        { "index_based_layout_orientation", reinterpret_cast<getter>(Layout_get_IndexBasedLayoutOrientation), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Layout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Layout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Layout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Layout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Layout) },
        { },
    };

    static PyType_Spec type_spec_Layout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Layout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Layout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Layout
    };

    // ----- LayoutContext class --------------------

    static PyObject* _new_LayoutContext(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>::type_name);
        return nullptr;
    }

    static void _dealloc_LayoutContext(py::wrapper::Microsoft::UI::Xaml::Controls::LayoutContext* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* LayoutContext_get_LayoutState(py::wrapper::Microsoft::UI::Xaml::Controls::LayoutContext* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LayoutContext", L"LayoutState"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LayoutState());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LayoutContext_put_LayoutState(py::wrapper::Microsoft::UI::Xaml::Controls::LayoutContext* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LayoutContext", L"LayoutState"))
        {
            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.LayoutState(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_LayoutContext(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_LayoutContext(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::LayoutContext>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_LayoutContext[] = {
        { "_assign_array_", _assign_array_LayoutContext, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_LayoutContext), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_LayoutContext[] = {
        { "layout_state", reinterpret_cast<getter>(LayoutContext_get_LayoutState), reinterpret_cast<setter>(LayoutContext_put_LayoutState), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_LayoutContext[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_LayoutContext) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LayoutContext) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_LayoutContext) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_LayoutContext) },
        { },
    };

    static PyType_Spec type_spec_LayoutContext =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.LayoutContext",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::LayoutContext),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_LayoutContext
    };

    // ----- LinedFlowLayout class --------------------

    static PyObject* _new_LinedFlowLayout(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::Microsoft::UI::Xaml::Controls::LinedFlowLayout 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_LinedFlowLayout(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* LinedFlowLayout_InvalidateItemsInfo(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"InvalidateItemsInfo", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.InvalidateItemsInfo();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_LockItemToLine(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"LockItemToLine", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.LockItemToLine(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_MinItemSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"MinItemSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinItemSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayout_put_MinItemSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"MinItemSpacing"))
        {
            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<double>(arg);

            self->obj.MinItemSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayout_get_LineSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"LineSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LineSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayout_put_LineSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"LineSpacing"))
        {
            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<double>(arg);

            self->obj.LineSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayout_get_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"LineHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LineHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayout_put_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"LineHeight"))
        {
            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<double>(arg);

            self->obj.LineHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayout_get_ItemsStretch(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsStretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsStretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayout_put_ItemsStretch(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsStretch"))
        {
            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::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsStretch>(arg);

            self->obj.ItemsStretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayout_get_ItemsJustification(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsJustification"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsJustification());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayout_put_ItemsJustification(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsJustification"))
        {
            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::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsJustification>(arg);

            self->obj.ItemsJustification(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayout_get_ActualLineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ActualLineHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActualLineHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_RequestedRangeLength(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"RequestedRangeLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RequestedRangeLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_RequestedRangeStartIndex(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"RequestedRangeStartIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RequestedRangeStartIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_ActualLineHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ActualLineHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout::ActualLineHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_ItemsJustificationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsJustificationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout::ItemsJustificationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_ItemsStretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsStretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout::ItemsStretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_LineHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"LineHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout::LineHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_LineSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"LineSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout::LineSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_get_MinItemSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"MinItemSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout::MinItemSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_add_ItemsInfoRequested(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsInfoRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout, winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs>>(arg);

            return py::convert(self->obj.ItemsInfoRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_remove_ItemsInfoRequested(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsInfoRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemsInfoRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_add_ItemsUnlocked(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsUnlocked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ItemsUnlocked(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayout_remove_ItemsUnlocked(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayout", L"ItemsUnlocked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemsUnlocked(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_LinedFlowLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_LinedFlowLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_LinedFlowLayout[] = {
        { "invalidate_items_info", reinterpret_cast<PyCFunction>(LinedFlowLayout_InvalidateItemsInfo), METH_VARARGS, nullptr },
        { "lock_item_to_line", reinterpret_cast<PyCFunction>(LinedFlowLayout_LockItemToLine), METH_VARARGS, nullptr },
        { "add_items_info_requested", reinterpret_cast<PyCFunction>(LinedFlowLayout_add_ItemsInfoRequested), METH_O, nullptr },
        { "remove_items_info_requested", reinterpret_cast<PyCFunction>(LinedFlowLayout_remove_ItemsInfoRequested), METH_O, nullptr },
        { "add_items_unlocked", reinterpret_cast<PyCFunction>(LinedFlowLayout_add_ItemsUnlocked), METH_O, nullptr },
        { "remove_items_unlocked", reinterpret_cast<PyCFunction>(LinedFlowLayout_remove_ItemsUnlocked), METH_O, nullptr },
        { "_assign_array_", _assign_array_LinedFlowLayout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_LinedFlowLayout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_LinedFlowLayout[] = {
        { "min_item_spacing", reinterpret_cast<getter>(LinedFlowLayout_get_MinItemSpacing), reinterpret_cast<setter>(LinedFlowLayout_put_MinItemSpacing), nullptr, nullptr },
        { "line_spacing", reinterpret_cast<getter>(LinedFlowLayout_get_LineSpacing), reinterpret_cast<setter>(LinedFlowLayout_put_LineSpacing), nullptr, nullptr },
        { "line_height", reinterpret_cast<getter>(LinedFlowLayout_get_LineHeight), reinterpret_cast<setter>(LinedFlowLayout_put_LineHeight), nullptr, nullptr },
        { "items_stretch", reinterpret_cast<getter>(LinedFlowLayout_get_ItemsStretch), reinterpret_cast<setter>(LinedFlowLayout_put_ItemsStretch), nullptr, nullptr },
        { "items_justification", reinterpret_cast<getter>(LinedFlowLayout_get_ItemsJustification), reinterpret_cast<setter>(LinedFlowLayout_put_ItemsJustification), nullptr, nullptr },
        { "actual_line_height", reinterpret_cast<getter>(LinedFlowLayout_get_ActualLineHeight), nullptr, nullptr, nullptr },
        { "requested_range_length", reinterpret_cast<getter>(LinedFlowLayout_get_RequestedRangeLength), nullptr, nullptr, nullptr },
        { "requested_range_start_index", reinterpret_cast<getter>(LinedFlowLayout_get_RequestedRangeStartIndex), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_LinedFlowLayout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_LinedFlowLayout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LinedFlowLayout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_LinedFlowLayout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_LinedFlowLayout) },
        { },
    };

    static PyType_Spec type_spec_LinedFlowLayout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.LinedFlowLayout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_LinedFlowLayout
    };

    static PyGetSetDef getset_LinedFlowLayout_Static[] = {
        { "actual_line_height_property", reinterpret_cast<getter>(LinedFlowLayout_get_ActualLineHeightProperty), nullptr, nullptr, nullptr },
        { "items_justification_property", reinterpret_cast<getter>(LinedFlowLayout_get_ItemsJustificationProperty), nullptr, nullptr, nullptr },
        { "items_stretch_property", reinterpret_cast<getter>(LinedFlowLayout_get_ItemsStretchProperty), nullptr, nullptr, nullptr },
        { "line_height_property", reinterpret_cast<getter>(LinedFlowLayout_get_LineHeightProperty), nullptr, nullptr, nullptr },
        { "line_spacing_property", reinterpret_cast<getter>(LinedFlowLayout_get_LineSpacingProperty), nullptr, nullptr, nullptr },
        { "min_item_spacing_property", reinterpret_cast<getter>(LinedFlowLayout_get_MinItemSpacingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_LinedFlowLayout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_LinedFlowLayout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_LinedFlowLayout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_LinedFlowLayout_Static) },
        { }
    };

    static PyType_Spec type_spec_LinedFlowLayout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.LinedFlowLayout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_LinedFlowLayout_Static
    };

    // ----- LinedFlowLayoutItemCollectionTransitionProvider class --------------------

    static PyObject* _new_LinedFlowLayoutItemCollectionTransitionProvider(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::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemCollectionTransitionProvider 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_LinedFlowLayoutItemCollectionTransitionProvider(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemCollectionTransitionProvider* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_LinedFlowLayoutItemCollectionTransitionProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemCollectionTransitionProvider>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_LinedFlowLayoutItemCollectionTransitionProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemCollectionTransitionProvider>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_LinedFlowLayoutItemCollectionTransitionProvider[] = {
        { "_assign_array_", _assign_array_LinedFlowLayoutItemCollectionTransitionProvider, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_LinedFlowLayoutItemCollectionTransitionProvider), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_LinedFlowLayoutItemCollectionTransitionProvider[] = {
        { }
    };

    static PyType_Slot _type_slots_LinedFlowLayoutItemCollectionTransitionProvider[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_LinedFlowLayoutItemCollectionTransitionProvider) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LinedFlowLayoutItemCollectionTransitionProvider) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_LinedFlowLayoutItemCollectionTransitionProvider) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_LinedFlowLayoutItemCollectionTransitionProvider) },
        { },
    };

    static PyType_Spec type_spec_LinedFlowLayoutItemCollectionTransitionProvider =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.LinedFlowLayoutItemCollectionTransitionProvider",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemCollectionTransitionProvider),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_LinedFlowLayoutItemCollectionTransitionProvider
    };

    // ----- LinedFlowLayoutItemsInfoRequestedEventArgs class --------------------

    static PyObject* _new_LinedFlowLayoutItemsInfoRequestedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_LinedFlowLayoutItemsInfoRequestedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* LinedFlowLayoutItemsInfoRequestedEventArgs_SetDesiredAspectRatios(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"SetDesiredAspectRatios", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<double, false>>(args, 0);

                self->obj.SetDesiredAspectRatios(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayoutItemsInfoRequestedEventArgs_SetMaxWidths(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"SetMaxWidths", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<double, false>>(args, 0);

                self->obj.SetMaxWidths(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayoutItemsInfoRequestedEventArgs_SetMinWidths(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"SetMinWidths", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<double, false>>(args, 0);

                self->obj.SetMinWidths(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* LinedFlowLayoutItemsInfoRequestedEventArgs_get_MinWidth(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"MinWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayoutItemsInfoRequestedEventArgs_put_MinWidth(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"MinWidth"))
        {
            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<double>(arg);

            self->obj.MinWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayoutItemsInfoRequestedEventArgs_get_MaxWidth(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"MaxWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayoutItemsInfoRequestedEventArgs_put_MaxWidth(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"MaxWidth"))
        {
            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<double>(arg);

            self->obj.MaxWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayoutItemsInfoRequestedEventArgs_get_ItemsRangeStartIndex(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"ItemsRangeStartIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsRangeStartIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int LinedFlowLayoutItemsInfoRequestedEventArgs_put_ItemsRangeStartIndex(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"ItemsRangeStartIndex"))
        {
            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<int32_t>(arg);

            self->obj.ItemsRangeStartIndex(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* LinedFlowLayoutItemsInfoRequestedEventArgs_get_ItemsRangeRequestedLength(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs", L"ItemsRangeRequestedLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsRangeRequestedLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_LinedFlowLayoutItemsInfoRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_LinedFlowLayoutItemsInfoRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_LinedFlowLayoutItemsInfoRequestedEventArgs[] = {
        { "set_desired_aspect_ratios", reinterpret_cast<PyCFunction>(LinedFlowLayoutItemsInfoRequestedEventArgs_SetDesiredAspectRatios), METH_VARARGS, nullptr },
        { "set_max_widths", reinterpret_cast<PyCFunction>(LinedFlowLayoutItemsInfoRequestedEventArgs_SetMaxWidths), METH_VARARGS, nullptr },
        { "set_min_widths", reinterpret_cast<PyCFunction>(LinedFlowLayoutItemsInfoRequestedEventArgs_SetMinWidths), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_LinedFlowLayoutItemsInfoRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_LinedFlowLayoutItemsInfoRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_LinedFlowLayoutItemsInfoRequestedEventArgs[] = {
        { "min_width", reinterpret_cast<getter>(LinedFlowLayoutItemsInfoRequestedEventArgs_get_MinWidth), reinterpret_cast<setter>(LinedFlowLayoutItemsInfoRequestedEventArgs_put_MinWidth), nullptr, nullptr },
        { "max_width", reinterpret_cast<getter>(LinedFlowLayoutItemsInfoRequestedEventArgs_get_MaxWidth), reinterpret_cast<setter>(LinedFlowLayoutItemsInfoRequestedEventArgs_put_MaxWidth), nullptr, nullptr },
        { "items_range_start_index", reinterpret_cast<getter>(LinedFlowLayoutItemsInfoRequestedEventArgs_get_ItemsRangeStartIndex), reinterpret_cast<setter>(LinedFlowLayoutItemsInfoRequestedEventArgs_put_ItemsRangeStartIndex), nullptr, nullptr },
        { "items_range_requested_length", reinterpret_cast<getter>(LinedFlowLayoutItemsInfoRequestedEventArgs_get_ItemsRangeRequestedLength), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_LinedFlowLayoutItemsInfoRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_LinedFlowLayoutItemsInfoRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_LinedFlowLayoutItemsInfoRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_LinedFlowLayoutItemsInfoRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_LinedFlowLayoutItemsInfoRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_LinedFlowLayoutItemsInfoRequestedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.LinedFlowLayoutItemsInfoRequestedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::LinedFlowLayoutItemsInfoRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_LinedFlowLayoutItemsInfoRequestedEventArgs
    };

    // ----- ListBox class --------------------

    static PyObject* _new_ListBox(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::Microsoft::UI::Xaml::Controls::ListBox 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_ListBox(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ListBox_ScrollIntoView(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"ScrollIntoView", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                self->obj.ScrollIntoView(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListBox_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListBox_get_SingleSelectionFollowsFocus(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SingleSelectionFollowsFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SingleSelectionFollowsFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListBox_put_SingleSelectionFollowsFocus(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SingleSelectionFollowsFocus"))
        {
            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.SingleSelectionFollowsFocus(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListBox_get_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SelectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListBox_put_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SelectionMode"))
        {
            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::Microsoft::UI::Xaml::Controls::SelectionMode>(arg);

            self->obj.SelectionMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListBox_get_SelectedItems(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SelectedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListBox_get_SelectionModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SelectionModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListBox::SelectionModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListBox_get_SingleSelectionFollowsFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListBox", L"SingleSelectionFollowsFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListBox::SingleSelectionFollowsFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ListBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListBox[] = {
        { "scroll_into_view", reinterpret_cast<PyCFunction>(ListBox_ScrollIntoView), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(ListBox_SelectAll), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ListBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListBox[] = {
        { "single_selection_follows_focus", reinterpret_cast<getter>(ListBox_get_SingleSelectionFollowsFocus), reinterpret_cast<setter>(ListBox_put_SingleSelectionFollowsFocus), nullptr, nullptr },
        { "selection_mode", reinterpret_cast<getter>(ListBox_get_SelectionMode), reinterpret_cast<setter>(ListBox_put_SelectionMode), nullptr, nullptr },
        { "selected_items", reinterpret_cast<getter>(ListBox_get_SelectedItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ListBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListBox) },
        { },
    };

    static PyType_Spec type_spec_ListBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListBox
    };

    static PyGetSetDef getset_ListBox_Static[] = {
        { "selection_mode_property", reinterpret_cast<getter>(ListBox_get_SelectionModeProperty), nullptr, nullptr, nullptr },
        { "single_selection_follows_focus_property", reinterpret_cast<getter>(ListBox_get_SingleSelectionFollowsFocusProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ListBox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ListBox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ListBox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ListBox_Static) },
        { }
    };

    static PyType_Spec type_spec_ListBox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListBox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ListBox_Static
    };

    // ----- ListBoxItem class --------------------

    static PyObject* _new_ListBoxItem(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::Microsoft::UI::Xaml::Controls::ListBoxItem 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_ListBoxItem(py::wrapper::Microsoft::UI::Xaml::Controls::ListBoxItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ListBoxItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListBoxItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListBoxItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListBoxItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListBoxItem[] = {
        { "_assign_array_", _assign_array_ListBoxItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListBoxItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListBoxItem[] = {
        { }
    };

    static PyType_Slot _type_slots_ListBoxItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListBoxItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListBoxItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListBoxItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListBoxItem) },
        { },
    };

    static PyType_Spec type_spec_ListBoxItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListBoxItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListBoxItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListBoxItem
    };

    // ----- ListPickerFlyout class --------------------

    static PyObject* _new_ListPickerFlyout(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::Microsoft::UI::Xaml::Controls::ListPickerFlyout 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_ListPickerFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ListPickerFlyout_ShowAtAsync(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ShowAtAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(self->obj.ShowAtAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectionMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ListPickerFlyoutSelectionMode>(arg);

            self->obj.SelectionMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedValuePath(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedValuePath"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedValuePath());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_SelectedValuePath(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedValuePath"))
        {
            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.SelectedValuePath(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedValue(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_SelectedValue(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedValue"))
        {
            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.SelectedValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedItem"))
        {
            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.SelectedItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedIndex"))
        {
            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<int32_t>(arg);

            self->obj.SelectedIndex(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.ItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_DisplayMemberPath(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"DisplayMemberPath"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisplayMemberPath());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListPickerFlyout_put_DisplayMemberPath(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"DisplayMemberPath"))
        {
            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.DisplayMemberPath(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedItems(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_DisplayMemberPathProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"DisplayMemberPathProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::DisplayMemberPathProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_ItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::ItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::SelectedIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedValuePathProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedValuePathProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::SelectedValuePathProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectedValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectedValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::SelectedValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_get_SelectionModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"SelectionModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout::SelectionModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_add_ItemsPicked(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemsPicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout, winrt::Microsoft::UI::Xaml::Controls::ItemsPickedEventArgs>>(arg);

            return py::convert(self->obj.ItemsPicked(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListPickerFlyout_remove_ItemsPicked(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListPickerFlyout", L"ItemsPicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemsPicked(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ListPickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListPickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListPickerFlyout[] = {
        { "show_at_async", reinterpret_cast<PyCFunction>(ListPickerFlyout_ShowAtAsync), METH_VARARGS, nullptr },
        { "add_items_picked", reinterpret_cast<PyCFunction>(ListPickerFlyout_add_ItemsPicked), METH_O, nullptr },
        { "remove_items_picked", reinterpret_cast<PyCFunction>(ListPickerFlyout_remove_ItemsPicked), METH_O, nullptr },
        { "_assign_array_", _assign_array_ListPickerFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListPickerFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListPickerFlyout[] = {
        { "selection_mode", reinterpret_cast<getter>(ListPickerFlyout_get_SelectionMode), reinterpret_cast<setter>(ListPickerFlyout_put_SelectionMode), nullptr, nullptr },
        { "selected_value_path", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedValuePath), reinterpret_cast<setter>(ListPickerFlyout_put_SelectedValuePath), nullptr, nullptr },
        { "selected_value", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedValue), reinterpret_cast<setter>(ListPickerFlyout_put_SelectedValue), nullptr, nullptr },
        { "selected_item", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedItem), reinterpret_cast<setter>(ListPickerFlyout_put_SelectedItem), nullptr, nullptr },
        { "selected_index", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedIndex), reinterpret_cast<setter>(ListPickerFlyout_put_SelectedIndex), nullptr, nullptr },
        { "items_source", reinterpret_cast<getter>(ListPickerFlyout_get_ItemsSource), reinterpret_cast<setter>(ListPickerFlyout_put_ItemsSource), nullptr, nullptr },
        { "item_template", reinterpret_cast<getter>(ListPickerFlyout_get_ItemTemplate), reinterpret_cast<setter>(ListPickerFlyout_put_ItemTemplate), nullptr, nullptr },
        { "display_member_path", reinterpret_cast<getter>(ListPickerFlyout_get_DisplayMemberPath), reinterpret_cast<setter>(ListPickerFlyout_put_DisplayMemberPath), nullptr, nullptr },
        { "selected_items", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ListPickerFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListPickerFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListPickerFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListPickerFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListPickerFlyout) },
        { },
    };

    static PyType_Spec type_spec_ListPickerFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListPickerFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListPickerFlyout
    };

    static PyGetSetDef getset_ListPickerFlyout_Static[] = {
        { "display_member_path_property", reinterpret_cast<getter>(ListPickerFlyout_get_DisplayMemberPathProperty), nullptr, nullptr, nullptr },
        { "item_template_property", reinterpret_cast<getter>(ListPickerFlyout_get_ItemTemplateProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(ListPickerFlyout_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { "selected_index_property", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedIndexProperty), nullptr, nullptr, nullptr },
        { "selected_item_property", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { "selected_value_path_property", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedValuePathProperty), nullptr, nullptr, nullptr },
        { "selected_value_property", reinterpret_cast<getter>(ListPickerFlyout_get_SelectedValueProperty), nullptr, nullptr, nullptr },
        { "selection_mode_property", reinterpret_cast<getter>(ListPickerFlyout_get_SelectionModeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ListPickerFlyout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ListPickerFlyout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ListPickerFlyout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ListPickerFlyout_Static) },
        { }
    };

    static PyType_Spec type_spec_ListPickerFlyout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListPickerFlyout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ListPickerFlyout_Static
    };

    // ----- ListPickerFlyoutPresenter class --------------------

    static PyObject* _new_ListPickerFlyoutPresenter(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyoutPresenter>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyoutPresenter>::type_name);
        return nullptr;
    }

    static void _dealloc_ListPickerFlyoutPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyoutPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ListPickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyoutPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListPickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListPickerFlyoutPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListPickerFlyoutPresenter[] = {
        { "_assign_array_", _assign_array_ListPickerFlyoutPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListPickerFlyoutPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListPickerFlyoutPresenter[] = {
        { }
    };

    static PyType_Slot _type_slots_ListPickerFlyoutPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListPickerFlyoutPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListPickerFlyoutPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListPickerFlyoutPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListPickerFlyoutPresenter) },
        { },
    };

    static PyType_Spec type_spec_ListPickerFlyoutPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListPickerFlyoutPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListPickerFlyoutPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListPickerFlyoutPresenter
    };

    // ----- ListView class --------------------

    static PyObject* _new_ListView(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::Microsoft::UI::Xaml::Controls::ListView 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_ListView(py::wrapper::Microsoft::UI::Xaml::Controls::ListView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ListView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListView[] = {
        { "_assign_array_", _assign_array_ListView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListView[] = {
        { }
    };

    static PyType_Slot _type_slots_ListView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListView) },
        { },
    };

    static PyType_Spec type_spec_ListView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListView
    };

    // ----- ListViewBase class --------------------

    static PyObject* _new_ListViewBase(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListViewBase>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListViewBase>::type_name);
        return nullptr;
    }

    static void _dealloc_ListViewBase(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ListViewBase_CompleteViewChange(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CompleteViewChange", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CompleteViewChange();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_CompleteViewChangeFrom(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CompleteViewChangeFrom", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.CompleteViewChangeFrom(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_CompleteViewChangeTo(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CompleteViewChangeTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.CompleteViewChangeTo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_DeselectRange(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DeselectRange", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Data::ItemIndexRange>(args, 0);

                self->obj.DeselectRange(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_InitializeViewChange(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"InitializeViewChange", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.InitializeViewChange();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_IsDragSource(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsDragSource", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.IsDragSource());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_LoadMoreItemsAsync(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"LoadMoreItemsAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.LoadMoreItemsAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_MakeVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"MakeVisible", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);

                self->obj.MakeVisible(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_PrepareConnectedAnimation(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"PrepareConnectedAnimation", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);

                return py::convert(self->obj.PrepareConnectedAnimation(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_ScrollIntoView(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ScrollIntoView", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                self->obj.ScrollIntoView(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ScrollIntoView", 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::Microsoft::UI::Xaml::Controls::ScrollIntoViewAlignment>(args, 1);

                self->obj.ScrollIntoView(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_SelectRange(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SelectRange", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Data::ItemIndexRange>(args, 0);

                self->obj.SelectRange(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_SetDesiredContainerUpdateDuration(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SetDesiredContainerUpdateDuration", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::TimeSpan>(args, 0);

                self->obj.SetDesiredContainerUpdateDuration(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_StartViewChangeFrom(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"StartViewChangeFrom", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.StartViewChangeFrom(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_StartViewChangeTo(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"StartViewChangeTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.StartViewChangeTo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_TryStartConnectedAnimationAsync(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"TryStartConnectedAnimationAsync", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Media::Animation::ConnectedAnimation>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);

                return py::convert(self->obj.TryStartConnectedAnimationAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_SingleSelectionFollowsFocus(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SingleSelectionFollowsFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SingleSelectionFollowsFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_SingleSelectionFollowsFocus(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SingleSelectionFollowsFocus"))
        {
            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.SingleSelectionFollowsFocus(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_ShowsScrollingPlaceholders(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ShowsScrollingPlaceholders"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ShowsScrollingPlaceholders());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_ShowsScrollingPlaceholders(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ShowsScrollingPlaceholders"))
        {
            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.ShowsScrollingPlaceholders(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SelectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SelectionMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ListViewSelectionMode>(arg);

            self->obj.SelectionMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_ReorderMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ReorderMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ReorderMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_ReorderMode(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ReorderMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ListViewReorderMode>(arg);

            self->obj.ReorderMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_IsSwipeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsSwipeEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSwipeEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_IsSwipeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsSwipeEnabled"))
        {
            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.IsSwipeEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_IsMultiSelectCheckBoxEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsMultiSelectCheckBoxEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsMultiSelectCheckBoxEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_IsMultiSelectCheckBoxEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsMultiSelectCheckBoxEnabled"))
        {
            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.IsMultiSelectCheckBoxEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_IsItemClickEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsItemClickEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsItemClickEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_IsItemClickEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsItemClickEnabled"))
        {
            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.IsItemClickEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_IncrementalLoadingTrigger(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IncrementalLoadingTrigger"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IncrementalLoadingTrigger());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_IncrementalLoadingTrigger(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IncrementalLoadingTrigger"))
        {
            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::Microsoft::UI::Xaml::Controls::IncrementalLoadingTrigger>(arg);

            self->obj.IncrementalLoadingTrigger(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_IncrementalLoadingThreshold(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IncrementalLoadingThreshold"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IncrementalLoadingThreshold());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_IncrementalLoadingThreshold(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IncrementalLoadingThreshold"))
        {
            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<double>(arg);

            self->obj.IncrementalLoadingThreshold(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_HeaderTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"HeaderTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTransitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_HeaderTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"HeaderTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

            self->obj.HeaderTransitions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_FooterTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"FooterTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FooterTransitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_FooterTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"FooterTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

            self->obj.FooterTransitions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_FooterTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"FooterTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FooterTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_FooterTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"FooterTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.FooterTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_Footer(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"Footer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Footer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_Footer(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"Footer"))
        {
            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.Footer(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_DataFetchSize(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DataFetchSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DataFetchSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_DataFetchSize(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DataFetchSize"))
        {
            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<double>(arg);

            self->obj.DataFetchSize(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_CanReorderItems(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CanReorderItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanReorderItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_CanReorderItems(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CanReorderItems"))
        {
            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.CanReorderItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_CanDragItems(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CanDragItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanDragItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_CanDragItems(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CanDragItems"))
        {
            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.CanDragItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_SelectedItems(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SelectedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_SelectedRanges(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SelectedRanges"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedRanges());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_SemanticZoomOwner(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SemanticZoomOwner"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SemanticZoomOwner());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_SemanticZoomOwner(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SemanticZoomOwner"))
        {
            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::Microsoft::UI::Xaml::Controls::SemanticZoom>(arg);

            self->obj.SemanticZoomOwner(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_IsZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsZoomedInView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomedInView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_IsZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsZoomedInView"))
        {
            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.IsZoomedInView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_IsActiveView(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsActiveView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsActiveView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ListViewBase_put_IsActiveView(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsActiveView"))
        {
            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.IsActiveView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ListViewBase_get_CanDragItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CanDragItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::CanDragItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_CanReorderItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"CanReorderItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::CanReorderItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_DataFetchSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DataFetchSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::DataFetchSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_FooterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"FooterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::FooterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_FooterTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"FooterTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::FooterTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_FooterTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"FooterTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::FooterTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_HeaderTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"HeaderTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::HeaderTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_IncrementalLoadingThresholdProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IncrementalLoadingThresholdProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::IncrementalLoadingThresholdProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_IncrementalLoadingTriggerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IncrementalLoadingTriggerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::IncrementalLoadingTriggerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_IsActiveViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsActiveViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::IsActiveViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_IsItemClickEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsItemClickEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::IsItemClickEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_IsMultiSelectCheckBoxEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsMultiSelectCheckBoxEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::IsMultiSelectCheckBoxEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_IsSwipeEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsSwipeEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::IsSwipeEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_IsZoomedInViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"IsZoomedInViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::IsZoomedInViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_ReorderModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ReorderModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::ReorderModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_SelectionModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SelectionModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::SelectionModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_SemanticZoomOwnerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SemanticZoomOwnerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::SemanticZoomOwnerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_ShowsScrollingPlaceholdersProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ShowsScrollingPlaceholdersProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::ShowsScrollingPlaceholdersProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_get_SingleSelectionFollowsFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"SingleSelectionFollowsFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewBase::SingleSelectionFollowsFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_add_ChoosingGroupHeaderContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ChoosingGroupHeaderContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ListViewBase, winrt::Microsoft::UI::Xaml::Controls::ChoosingGroupHeaderContainerEventArgs>>(arg);

            return py::convert(self->obj.ChoosingGroupHeaderContainer(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_remove_ChoosingGroupHeaderContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ChoosingGroupHeaderContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ChoosingGroupHeaderContainer(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_add_ChoosingItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ChoosingItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ListViewBase, winrt::Microsoft::UI::Xaml::Controls::ChoosingItemContainerEventArgs>>(arg);

            return py::convert(self->obj.ChoosingItemContainer(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_remove_ChoosingItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ChoosingItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ChoosingItemContainer(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_add_ContainerContentChanging(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ContainerContentChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ListViewBase, winrt::Microsoft::UI::Xaml::Controls::ContainerContentChangingEventArgs>>(arg);

            return py::convert(self->obj.ContainerContentChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_remove_ContainerContentChanging(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ContainerContentChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ContainerContentChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_add_DragItemsCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DragItemsCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ListViewBase, winrt::Microsoft::UI::Xaml::Controls::DragItemsCompletedEventArgs>>(arg);

            return py::convert(self->obj.DragItemsCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_remove_DragItemsCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DragItemsCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.DragItemsCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_add_DragItemsStarting(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DragItemsStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::DragItemsStartingEventHandler>(arg);

            return py::convert(self->obj.DragItemsStarting(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_remove_DragItemsStarting(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"DragItemsStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.DragItemsStarting(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_add_ItemClick(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ItemClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ItemClickEventHandler>(arg);

            return py::convert(self->obj.ItemClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListViewBase_remove_ItemClick(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ListViewBase", L"ItemClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ListViewBase(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListViewBase>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListViewBase(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListViewBase>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListViewBase[] = {
        { "complete_view_change", reinterpret_cast<PyCFunction>(ListViewBase_CompleteViewChange), METH_VARARGS, nullptr },
        { "complete_view_change_from", reinterpret_cast<PyCFunction>(ListViewBase_CompleteViewChangeFrom), METH_VARARGS, nullptr },
        { "complete_view_change_to", reinterpret_cast<PyCFunction>(ListViewBase_CompleteViewChangeTo), METH_VARARGS, nullptr },
        { "deselect_range", reinterpret_cast<PyCFunction>(ListViewBase_DeselectRange), METH_VARARGS, nullptr },
        { "initialize_view_change", reinterpret_cast<PyCFunction>(ListViewBase_InitializeViewChange), METH_VARARGS, nullptr },
        { "is_drag_source", reinterpret_cast<PyCFunction>(ListViewBase_IsDragSource), METH_VARARGS, nullptr },
        { "load_more_items_async", reinterpret_cast<PyCFunction>(ListViewBase_LoadMoreItemsAsync), METH_VARARGS, nullptr },
        { "make_visible", reinterpret_cast<PyCFunction>(ListViewBase_MakeVisible), METH_VARARGS, nullptr },
        { "prepare_connected_animation", reinterpret_cast<PyCFunction>(ListViewBase_PrepareConnectedAnimation), METH_VARARGS, nullptr },
        { "scroll_into_view", reinterpret_cast<PyCFunction>(ListViewBase_ScrollIntoView), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(ListViewBase_SelectAll), METH_VARARGS, nullptr },
        { "select_range", reinterpret_cast<PyCFunction>(ListViewBase_SelectRange), METH_VARARGS, nullptr },
        { "set_desired_container_update_duration", reinterpret_cast<PyCFunction>(ListViewBase_SetDesiredContainerUpdateDuration), METH_VARARGS, nullptr },
        { "start_view_change_from", reinterpret_cast<PyCFunction>(ListViewBase_StartViewChangeFrom), METH_VARARGS, nullptr },
        { "start_view_change_to", reinterpret_cast<PyCFunction>(ListViewBase_StartViewChangeTo), METH_VARARGS, nullptr },
        { "try_start_connected_animation_async", reinterpret_cast<PyCFunction>(ListViewBase_TryStartConnectedAnimationAsync), METH_VARARGS, nullptr },
        { "add_choosing_group_header_container", reinterpret_cast<PyCFunction>(ListViewBase_add_ChoosingGroupHeaderContainer), METH_O, nullptr },
        { "remove_choosing_group_header_container", reinterpret_cast<PyCFunction>(ListViewBase_remove_ChoosingGroupHeaderContainer), METH_O, nullptr },
        { "add_choosing_item_container", reinterpret_cast<PyCFunction>(ListViewBase_add_ChoosingItemContainer), METH_O, nullptr },
        { "remove_choosing_item_container", reinterpret_cast<PyCFunction>(ListViewBase_remove_ChoosingItemContainer), METH_O, nullptr },
        { "add_container_content_changing", reinterpret_cast<PyCFunction>(ListViewBase_add_ContainerContentChanging), METH_O, nullptr },
        { "remove_container_content_changing", reinterpret_cast<PyCFunction>(ListViewBase_remove_ContainerContentChanging), METH_O, nullptr },
        { "add_drag_items_completed", reinterpret_cast<PyCFunction>(ListViewBase_add_DragItemsCompleted), METH_O, nullptr },
        { "remove_drag_items_completed", reinterpret_cast<PyCFunction>(ListViewBase_remove_DragItemsCompleted), METH_O, nullptr },
        { "add_drag_items_starting", reinterpret_cast<PyCFunction>(ListViewBase_add_DragItemsStarting), METH_O, nullptr },
        { "remove_drag_items_starting", reinterpret_cast<PyCFunction>(ListViewBase_remove_DragItemsStarting), METH_O, nullptr },
        { "add_item_click", reinterpret_cast<PyCFunction>(ListViewBase_add_ItemClick), METH_O, nullptr },
        { "remove_item_click", reinterpret_cast<PyCFunction>(ListViewBase_remove_ItemClick), METH_O, nullptr },
        { "_assign_array_", _assign_array_ListViewBase, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListViewBase), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListViewBase[] = {
        { "single_selection_follows_focus", reinterpret_cast<getter>(ListViewBase_get_SingleSelectionFollowsFocus), reinterpret_cast<setter>(ListViewBase_put_SingleSelectionFollowsFocus), nullptr, nullptr },
        { "shows_scrolling_placeholders", reinterpret_cast<getter>(ListViewBase_get_ShowsScrollingPlaceholders), reinterpret_cast<setter>(ListViewBase_put_ShowsScrollingPlaceholders), nullptr, nullptr },
        { "selection_mode", reinterpret_cast<getter>(ListViewBase_get_SelectionMode), reinterpret_cast<setter>(ListViewBase_put_SelectionMode), nullptr, nullptr },
        { "reorder_mode", reinterpret_cast<getter>(ListViewBase_get_ReorderMode), reinterpret_cast<setter>(ListViewBase_put_ReorderMode), nullptr, nullptr },
        { "is_swipe_enabled", reinterpret_cast<getter>(ListViewBase_get_IsSwipeEnabled), reinterpret_cast<setter>(ListViewBase_put_IsSwipeEnabled), nullptr, nullptr },
        { "is_multi_select_check_box_enabled", reinterpret_cast<getter>(ListViewBase_get_IsMultiSelectCheckBoxEnabled), reinterpret_cast<setter>(ListViewBase_put_IsMultiSelectCheckBoxEnabled), nullptr, nullptr },
        { "is_item_click_enabled", reinterpret_cast<getter>(ListViewBase_get_IsItemClickEnabled), reinterpret_cast<setter>(ListViewBase_put_IsItemClickEnabled), nullptr, nullptr },
        { "incremental_loading_trigger", reinterpret_cast<getter>(ListViewBase_get_IncrementalLoadingTrigger), reinterpret_cast<setter>(ListViewBase_put_IncrementalLoadingTrigger), nullptr, nullptr },
        { "incremental_loading_threshold", reinterpret_cast<getter>(ListViewBase_get_IncrementalLoadingThreshold), reinterpret_cast<setter>(ListViewBase_put_IncrementalLoadingThreshold), nullptr, nullptr },
        { "header_transitions", reinterpret_cast<getter>(ListViewBase_get_HeaderTransitions), reinterpret_cast<setter>(ListViewBase_put_HeaderTransitions), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(ListViewBase_get_HeaderTemplate), reinterpret_cast<setter>(ListViewBase_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(ListViewBase_get_Header), reinterpret_cast<setter>(ListViewBase_put_Header), nullptr, nullptr },
        { "footer_transitions", reinterpret_cast<getter>(ListViewBase_get_FooterTransitions), reinterpret_cast<setter>(ListViewBase_put_FooterTransitions), nullptr, nullptr },
        { "footer_template", reinterpret_cast<getter>(ListViewBase_get_FooterTemplate), reinterpret_cast<setter>(ListViewBase_put_FooterTemplate), nullptr, nullptr },
        { "footer", reinterpret_cast<getter>(ListViewBase_get_Footer), reinterpret_cast<setter>(ListViewBase_put_Footer), nullptr, nullptr },
        { "data_fetch_size", reinterpret_cast<getter>(ListViewBase_get_DataFetchSize), reinterpret_cast<setter>(ListViewBase_put_DataFetchSize), nullptr, nullptr },
        { "can_reorder_items", reinterpret_cast<getter>(ListViewBase_get_CanReorderItems), reinterpret_cast<setter>(ListViewBase_put_CanReorderItems), nullptr, nullptr },
        { "can_drag_items", reinterpret_cast<getter>(ListViewBase_get_CanDragItems), reinterpret_cast<setter>(ListViewBase_put_CanDragItems), nullptr, nullptr },
        { "selected_items", reinterpret_cast<getter>(ListViewBase_get_SelectedItems), nullptr, nullptr, nullptr },
        { "selected_ranges", reinterpret_cast<getter>(ListViewBase_get_SelectedRanges), nullptr, nullptr, nullptr },
        { "semantic_zoom_owner", reinterpret_cast<getter>(ListViewBase_get_SemanticZoomOwner), reinterpret_cast<setter>(ListViewBase_put_SemanticZoomOwner), nullptr, nullptr },
        { "is_zoomed_in_view", reinterpret_cast<getter>(ListViewBase_get_IsZoomedInView), reinterpret_cast<setter>(ListViewBase_put_IsZoomedInView), nullptr, nullptr },
        { "is_active_view", reinterpret_cast<getter>(ListViewBase_get_IsActiveView), reinterpret_cast<setter>(ListViewBase_put_IsActiveView), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ListViewBase[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListViewBase) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListViewBase) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListViewBase) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListViewBase) },
        { },
    };

    static PyType_Spec type_spec_ListViewBase =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListViewBase",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBase),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListViewBase
    };

    static PyGetSetDef getset_ListViewBase_Static[] = {
        { "can_drag_items_property", reinterpret_cast<getter>(ListViewBase_get_CanDragItemsProperty), nullptr, nullptr, nullptr },
        { "can_reorder_items_property", reinterpret_cast<getter>(ListViewBase_get_CanReorderItemsProperty), nullptr, nullptr, nullptr },
        { "data_fetch_size_property", reinterpret_cast<getter>(ListViewBase_get_DataFetchSizeProperty), nullptr, nullptr, nullptr },
        { "footer_property", reinterpret_cast<getter>(ListViewBase_get_FooterProperty), nullptr, nullptr, nullptr },
        { "footer_template_property", reinterpret_cast<getter>(ListViewBase_get_FooterTemplateProperty), nullptr, nullptr, nullptr },
        { "footer_transitions_property", reinterpret_cast<getter>(ListViewBase_get_FooterTransitionsProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(ListViewBase_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(ListViewBase_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "header_transitions_property", reinterpret_cast<getter>(ListViewBase_get_HeaderTransitionsProperty), nullptr, nullptr, nullptr },
        { "incremental_loading_threshold_property", reinterpret_cast<getter>(ListViewBase_get_IncrementalLoadingThresholdProperty), nullptr, nullptr, nullptr },
        { "incremental_loading_trigger_property", reinterpret_cast<getter>(ListViewBase_get_IncrementalLoadingTriggerProperty), nullptr, nullptr, nullptr },
        { "is_active_view_property", reinterpret_cast<getter>(ListViewBase_get_IsActiveViewProperty), nullptr, nullptr, nullptr },
        { "is_item_click_enabled_property", reinterpret_cast<getter>(ListViewBase_get_IsItemClickEnabledProperty), nullptr, nullptr, nullptr },
        { "is_multi_select_check_box_enabled_property", reinterpret_cast<getter>(ListViewBase_get_IsMultiSelectCheckBoxEnabledProperty), nullptr, nullptr, nullptr },
        { "is_swipe_enabled_property", reinterpret_cast<getter>(ListViewBase_get_IsSwipeEnabledProperty), nullptr, nullptr, nullptr },
        { "is_zoomed_in_view_property", reinterpret_cast<getter>(ListViewBase_get_IsZoomedInViewProperty), nullptr, nullptr, nullptr },
        { "reorder_mode_property", reinterpret_cast<getter>(ListViewBase_get_ReorderModeProperty), nullptr, nullptr, nullptr },
        { "selection_mode_property", reinterpret_cast<getter>(ListViewBase_get_SelectionModeProperty), nullptr, nullptr, nullptr },
        { "semantic_zoom_owner_property", reinterpret_cast<getter>(ListViewBase_get_SemanticZoomOwnerProperty), nullptr, nullptr, nullptr },
        { "shows_scrolling_placeholders_property", reinterpret_cast<getter>(ListViewBase_get_ShowsScrollingPlaceholdersProperty), nullptr, nullptr, nullptr },
        { "single_selection_follows_focus_property", reinterpret_cast<getter>(ListViewBase_get_SingleSelectionFollowsFocusProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ListViewBase_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ListViewBase_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ListViewBase_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ListViewBase_Static) },
        { }
    };

    static PyType_Spec type_spec_ListViewBase_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListViewBase_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ListViewBase_Static
    };

    // ----- ListViewBaseHeaderItem class --------------------

    static PyObject* _new_ListViewBaseHeaderItem(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListViewBaseHeaderItem>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListViewBaseHeaderItem>::type_name);
        return nullptr;
    }

    static void _dealloc_ListViewBaseHeaderItem(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBaseHeaderItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ListViewBaseHeaderItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListViewBaseHeaderItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListViewBaseHeaderItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListViewBaseHeaderItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListViewBaseHeaderItem[] = {
        { "_assign_array_", _assign_array_ListViewBaseHeaderItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListViewBaseHeaderItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListViewBaseHeaderItem[] = {
        { }
    };

    static PyType_Slot _type_slots_ListViewBaseHeaderItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListViewBaseHeaderItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListViewBaseHeaderItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListViewBaseHeaderItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListViewBaseHeaderItem) },
        { },
    };

    static PyType_Spec type_spec_ListViewBaseHeaderItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListViewBaseHeaderItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewBaseHeaderItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListViewBaseHeaderItem
    };

    // ----- ListViewHeaderItem class --------------------

    static PyObject* _new_ListViewHeaderItem(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::Microsoft::UI::Xaml::Controls::ListViewHeaderItem 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_ListViewHeaderItem(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewHeaderItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ListViewHeaderItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListViewHeaderItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListViewHeaderItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListViewHeaderItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListViewHeaderItem[] = {
        { "_assign_array_", _assign_array_ListViewHeaderItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListViewHeaderItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListViewHeaderItem[] = {
        { }
    };

    static PyType_Slot _type_slots_ListViewHeaderItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListViewHeaderItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListViewHeaderItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListViewHeaderItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListViewHeaderItem) },
        { },
    };

    static PyType_Spec type_spec_ListViewHeaderItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListViewHeaderItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewHeaderItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListViewHeaderItem
    };

    // ----- ListViewItem class --------------------

    static PyObject* _new_ListViewItem(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::Microsoft::UI::Xaml::Controls::ListViewItem 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_ListViewItem(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ListViewItem_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ListViewItem", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ListViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListViewItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListViewItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListViewItem[] = {
        { "_assign_array_", _assign_array_ListViewItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListViewItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListViewItem[] = {
        { "template_settings", reinterpret_cast<getter>(ListViewItem_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ListViewItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListViewItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListViewItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListViewItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListViewItem) },
        { },
    };

    static PyType_Spec type_spec_ListViewItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListViewItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListViewItem
    };

    // ----- ListViewPersistenceHelper class --------------------

    static PyObject* _new_ListViewPersistenceHelper(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper>::type_name);
        return nullptr;
    }

    static void _dealloc_ListViewPersistenceHelper(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ListViewPersistenceHelper_GetRelativeScrollPosition(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewPersistenceHelper", L"GetRelativeScrollPosition", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ListViewBase>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ListViewItemToKeyHandler>(args, 1);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper::GetRelativeScrollPosition(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ListViewPersistenceHelper_SetRelativeScrollPositionAsync(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ListViewPersistenceHelper", L"SetRelativeScrollPositionAsync", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ListViewBase>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ListViewKeyToItemHandler>(args, 2);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper::SetRelativeScrollPositionAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_ListViewPersistenceHelper(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ListViewPersistenceHelper(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ListViewPersistenceHelper[] = {
        { "_assign_array_", _assign_array_ListViewPersistenceHelper, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ListViewPersistenceHelper), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ListViewPersistenceHelper[] = {
        { }
    };

    static PyType_Slot _type_slots_ListViewPersistenceHelper[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ListViewPersistenceHelper) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ListViewPersistenceHelper) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ListViewPersistenceHelper) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ListViewPersistenceHelper) },
        { },
    };

    static PyType_Spec type_spec_ListViewPersistenceHelper =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListViewPersistenceHelper",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ListViewPersistenceHelper),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListViewPersistenceHelper
    };

    static PyGetSetDef getset_ListViewPersistenceHelper_Static[] = {
        { }
    };

    static PyMethodDef methods_ListViewPersistenceHelper_Static[] = {
        { "get_relative_scroll_position", reinterpret_cast<PyCFunction>(ListViewPersistenceHelper_GetRelativeScrollPosition), METH_VARARGS, nullptr },
        { "set_relative_scroll_position_async", reinterpret_cast<PyCFunction>(ListViewPersistenceHelper_SetRelativeScrollPositionAsync), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_ListViewPersistenceHelper_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ListViewPersistenceHelper_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ListViewPersistenceHelper_Static) },
        { }
    };

    static PyType_Spec type_spec_ListViewPersistenceHelper_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ListViewPersistenceHelper_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ListViewPersistenceHelper_Static
    };

    // ----- MapControl class --------------------

    static PyObject* _new_MapControl(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::Microsoft::UI::Xaml::Controls::MapControl 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_MapControl(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MapControl_get_ZoomLevel(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"ZoomLevel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomLevel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MapControl_put_ZoomLevel(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"ZoomLevel"))
        {
            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<double>(arg);

            self->obj.ZoomLevel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MapControl_get_MapServiceToken(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"MapServiceToken"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MapServiceToken());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MapControl_put_MapServiceToken(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"MapServiceToken"))
        {
            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.MapServiceToken(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MapControl_get_Layers(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"Layers"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Layers());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MapControl_put_Layers(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"Layers"))
        {
            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::Collections::IVector<winrt::Microsoft::UI::Xaml::Controls::MapLayer>>(arg);

            self->obj.Layers(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MapControl_get_InteractiveControlsVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"InteractiveControlsVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InteractiveControlsVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MapControl_put_InteractiveControlsVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"InteractiveControlsVisible"))
        {
            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.InteractiveControlsVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MapControl_get_Center(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"Center"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Center());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MapControl_put_Center(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"Center"))
        {
            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::Devices::Geolocation::Geopoint>(arg);

            self->obj.Center(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MapControl_get_CenterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"CenterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MapControl::CenterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_get_InteractiveControlsVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"InteractiveControlsVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MapControl::InteractiveControlsVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_get_LayersProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"LayersProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MapControl::LayersProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_get_MapServiceTokenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"MapServiceTokenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MapControl::MapServiceTokenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_get_ZoomLevelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"ZoomLevelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MapControl::ZoomLevelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_add_MapElementClick(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"MapElementClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::MapControl, winrt::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs>>(arg);

            return py::convert(self->obj.MapElementClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_remove_MapElementClick(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"MapElementClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.MapElementClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_add_MapServiceErrorOccurred(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"MapServiceErrorOccurred"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::MapControl, winrt::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs>>(arg);

            return py::convert(self->obj.MapServiceErrorOccurred(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapControl_remove_MapServiceErrorOccurred(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MapControl", L"MapServiceErrorOccurred"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.MapServiceErrorOccurred(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MapControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MapControl>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MapControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MapControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MapControl[] = {
        { "add_map_element_click", reinterpret_cast<PyCFunction>(MapControl_add_MapElementClick), METH_O, nullptr },
        { "remove_map_element_click", reinterpret_cast<PyCFunction>(MapControl_remove_MapElementClick), METH_O, nullptr },
        { "add_map_service_error_occurred", reinterpret_cast<PyCFunction>(MapControl_add_MapServiceErrorOccurred), METH_O, nullptr },
        { "remove_map_service_error_occurred", reinterpret_cast<PyCFunction>(MapControl_remove_MapServiceErrorOccurred), METH_O, nullptr },
        { "_assign_array_", _assign_array_MapControl, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MapControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MapControl[] = {
        { "zoom_level", reinterpret_cast<getter>(MapControl_get_ZoomLevel), reinterpret_cast<setter>(MapControl_put_ZoomLevel), nullptr, nullptr },
        { "map_service_token", reinterpret_cast<getter>(MapControl_get_MapServiceToken), reinterpret_cast<setter>(MapControl_put_MapServiceToken), nullptr, nullptr },
        { "layers", reinterpret_cast<getter>(MapControl_get_Layers), reinterpret_cast<setter>(MapControl_put_Layers), nullptr, nullptr },
        { "interactive_controls_visible", reinterpret_cast<getter>(MapControl_get_InteractiveControlsVisible), reinterpret_cast<setter>(MapControl_put_InteractiveControlsVisible), nullptr, nullptr },
        { "center", reinterpret_cast<getter>(MapControl_get_Center), reinterpret_cast<setter>(MapControl_put_Center), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MapControl[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MapControl) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MapControl) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MapControl) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MapControl) },
        { },
    };

    static PyType_Spec type_spec_MapControl =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapControl",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MapControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MapControl
    };

    static PyGetSetDef getset_MapControl_Static[] = {
        { "center_property", reinterpret_cast<getter>(MapControl_get_CenterProperty), nullptr, nullptr, nullptr },
        { "interactive_controls_visible_property", reinterpret_cast<getter>(MapControl_get_InteractiveControlsVisibleProperty), nullptr, nullptr, nullptr },
        { "layers_property", reinterpret_cast<getter>(MapControl_get_LayersProperty), nullptr, nullptr, nullptr },
        { "map_service_token_property", reinterpret_cast<getter>(MapControl_get_MapServiceTokenProperty), nullptr, nullptr, nullptr },
        { "zoom_level_property", reinterpret_cast<getter>(MapControl_get_ZoomLevelProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MapControl_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MapControl_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MapControl_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MapControl_Static) },
        { }
    };

    static PyType_Spec type_spec_MapControl_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapControl_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MapControl_Static
    };

    // ----- MapControlMapServiceErrorOccurredEventArgs class --------------------

    static PyObject* _new_MapControlMapServiceErrorOccurredEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_MapControlMapServiceErrorOccurredEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MapControlMapServiceErrorOccurredEventArgs_get_DiagnosticMessage(py::wrapper::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapControlMapServiceErrorOccurredEventArgs", L"DiagnosticMessage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DiagnosticMessage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MapControlMapServiceErrorOccurredEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MapControlMapServiceErrorOccurredEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MapControlMapServiceErrorOccurredEventArgs[] = {
        { "_assign_array_", _assign_array_MapControlMapServiceErrorOccurredEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MapControlMapServiceErrorOccurredEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MapControlMapServiceErrorOccurredEventArgs[] = {
        { "diagnostic_message", reinterpret_cast<getter>(MapControlMapServiceErrorOccurredEventArgs_get_DiagnosticMessage), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MapControlMapServiceErrorOccurredEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MapControlMapServiceErrorOccurredEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MapControlMapServiceErrorOccurredEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MapControlMapServiceErrorOccurredEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MapControlMapServiceErrorOccurredEventArgs) },
        { },
    };

    static PyType_Spec type_spec_MapControlMapServiceErrorOccurredEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapControlMapServiceErrorOccurredEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MapControlMapServiceErrorOccurredEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MapControlMapServiceErrorOccurredEventArgs
    };

    // ----- MapElement class --------------------

    static PyObject* _new_MapElement(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapElement>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapElement>::type_name);
        return nullptr;
    }

    static void _dealloc_MapElement(py::wrapper::Microsoft::UI::Xaml::Controls::MapElement* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_MapElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MapElement>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MapElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MapElement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MapElement[] = {
        { "_assign_array_", _assign_array_MapElement, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MapElement), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MapElement[] = {
        { }
    };

    static PyType_Slot _type_slots_MapElement[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MapElement) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MapElement) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MapElement) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MapElement) },
        { },
    };

    static PyType_Spec type_spec_MapElement =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapElement",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MapElement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MapElement
    };

    // ----- MapElementClickEventArgs class --------------------

    static PyObject* _new_MapElementClickEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_MapElementClickEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MapElementClickEventArgs_get_Element(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapElementClickEventArgs", L"Element"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Element());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapElementClickEventArgs_get_Location(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapElementClickEventArgs", L"Location"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Location());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MapElementClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MapElementClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MapElementClickEventArgs[] = {
        { "_assign_array_", _assign_array_MapElementClickEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MapElementClickEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MapElementClickEventArgs[] = {
        { "element", reinterpret_cast<getter>(MapElementClickEventArgs_get_Element), nullptr, nullptr, nullptr },
        { "location", reinterpret_cast<getter>(MapElementClickEventArgs_get_Location), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MapElementClickEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MapElementClickEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MapElementClickEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MapElementClickEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MapElementClickEventArgs) },
        { },
    };

    static PyType_Spec type_spec_MapElementClickEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapElementClickEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MapElementClickEventArgs
    };

    // ----- MapElementsLayer class --------------------

    static PyObject* _new_MapElementsLayer(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::Microsoft::UI::Xaml::Controls::MapElementsLayer 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_MapElementsLayer(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementsLayer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MapElementsLayer_get_MapElements(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementsLayer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapElementsLayer", L"MapElements"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MapElements());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MapElementsLayer_put_MapElements(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementsLayer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapElementsLayer", L"MapElements"))
        {
            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::Collections::IVector<winrt::Microsoft::UI::Xaml::Controls::MapElement>>(arg);

            self->obj.MapElements(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MapElementsLayer_get_MapElementsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapElementsLayer", L"MapElementsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MapElementsLayer::MapElementsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapElementsLayer_add_MapElementClick(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementsLayer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MapElementsLayer", L"MapElementClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::MapElementsLayer, winrt::Microsoft::UI::Xaml::Controls::MapElementClickEventArgs>>(arg);

            return py::convert(self->obj.MapElementClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MapElementsLayer_remove_MapElementClick(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementsLayer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MapElementsLayer", L"MapElementClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.MapElementClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MapElementsLayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MapElementsLayer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MapElementsLayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MapElementsLayer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MapElementsLayer[] = {
        { "add_map_element_click", reinterpret_cast<PyCFunction>(MapElementsLayer_add_MapElementClick), METH_O, nullptr },
        { "remove_map_element_click", reinterpret_cast<PyCFunction>(MapElementsLayer_remove_MapElementClick), METH_O, nullptr },
        { "_assign_array_", _assign_array_MapElementsLayer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MapElementsLayer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MapElementsLayer[] = {
        { "map_elements", reinterpret_cast<getter>(MapElementsLayer_get_MapElements), reinterpret_cast<setter>(MapElementsLayer_put_MapElements), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MapElementsLayer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MapElementsLayer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MapElementsLayer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MapElementsLayer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MapElementsLayer) },
        { },
    };

    static PyType_Spec type_spec_MapElementsLayer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapElementsLayer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MapElementsLayer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MapElementsLayer
    };

    static PyGetSetDef getset_MapElementsLayer_Static[] = {
        { "map_elements_property", reinterpret_cast<getter>(MapElementsLayer_get_MapElementsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MapElementsLayer_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MapElementsLayer_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MapElementsLayer_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MapElementsLayer_Static) },
        { }
    };

    static PyType_Spec type_spec_MapElementsLayer_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapElementsLayer_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MapElementsLayer_Static
    };

    // ----- MapIcon class --------------------

    static PyObject* _new_MapIcon(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::Microsoft::UI::Xaml::Controls::MapIcon 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_MapIcon(py::wrapper::Microsoft::UI::Xaml::Controls::MapIcon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MapIcon_get_Location(py::wrapper::Microsoft::UI::Xaml::Controls::MapIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapIcon", L"Location"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Location());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MapIcon_put_Location(py::wrapper::Microsoft::UI::Xaml::Controls::MapIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapIcon", L"Location"))
        {
            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::Devices::Geolocation::Geopoint>(arg);

            self->obj.Location(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MapIcon_get_LocationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MapIcon", L"LocationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MapIcon::LocationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MapIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MapIcon>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MapIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MapIcon>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MapIcon[] = {
        { "_assign_array_", _assign_array_MapIcon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MapIcon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MapIcon[] = {
        { "location", reinterpret_cast<getter>(MapIcon_get_Location), reinterpret_cast<setter>(MapIcon_put_Location), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MapIcon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MapIcon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MapIcon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MapIcon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MapIcon) },
        { },
    };

    static PyType_Spec type_spec_MapIcon =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapIcon",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MapIcon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MapIcon
    };

    static PyGetSetDef getset_MapIcon_Static[] = {
        { "location_property", reinterpret_cast<getter>(MapIcon_get_LocationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MapIcon_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MapIcon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MapIcon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MapIcon_Static) },
        { }
    };

    static PyType_Spec type_spec_MapIcon_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapIcon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MapIcon_Static
    };

    // ----- MapLayer class --------------------

    static PyObject* _new_MapLayer(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapLayer>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MapLayer>::type_name);
        return nullptr;
    }

    static void _dealloc_MapLayer(py::wrapper::Microsoft::UI::Xaml::Controls::MapLayer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_MapLayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MapLayer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MapLayer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MapLayer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MapLayer[] = {
        { "_assign_array_", _assign_array_MapLayer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MapLayer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MapLayer[] = {
        { }
    };

    static PyType_Slot _type_slots_MapLayer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MapLayer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MapLayer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MapLayer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MapLayer) },
        { },
    };

    static PyType_Spec type_spec_MapLayer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MapLayer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MapLayer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MapLayer
    };

    // ----- MediaPlayerElement class --------------------

    static PyObject* _new_MediaPlayerElement(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::Microsoft::UI::Xaml::Controls::MediaPlayerElement 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_MediaPlayerElement(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MediaPlayerElement_SetMediaPlayer(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"SetMediaPlayer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Media::Playback::MediaPlayer>(args, 0);

                self->obj.SetMediaPlayer(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_TransportControls(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"TransportControls"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TransportControls());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerElement_put_TransportControls(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"TransportControls"))
        {
            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::Microsoft::UI::Xaml::Controls::MediaTransportControls>(arg);

            self->obj.TransportControls(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerElement_get_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"Stretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Stretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerElement_put_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"Stretch"))
        {
            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::Microsoft::UI::Xaml::Media::Stretch>(arg);

            self->obj.Stretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerElement_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Source());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerElement_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"Source"))
        {
            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::Media::Playback::IMediaPlaybackSource>(arg);

            self->obj.Source(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerElement_get_PosterSource(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"PosterSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PosterSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerElement_put_PosterSource(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"PosterSource"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.PosterSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerElement_get_IsFullWindow(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"IsFullWindow"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsFullWindow());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerElement_put_IsFullWindow(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"IsFullWindow"))
        {
            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.IsFullWindow(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerElement_get_AutoPlay(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"AutoPlay"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AutoPlay());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerElement_put_AutoPlay(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"AutoPlay"))
        {
            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.AutoPlay(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerElement_get_AreTransportControlsEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"AreTransportControlsEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreTransportControlsEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerElement_put_AreTransportControlsEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"AreTransportControlsEnabled"))
        {
            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.AreTransportControlsEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerElement_get_MediaPlayer(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"MediaPlayer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MediaPlayer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_AreTransportControlsEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"AreTransportControlsEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement::AreTransportControlsEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_AutoPlayProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"AutoPlayProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement::AutoPlayProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_IsFullWindowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"IsFullWindowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement::IsFullWindowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_MediaPlayerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"MediaPlayerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement::MediaPlayerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_PosterSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"PosterSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement::PosterSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerElement_get_StretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerElement", L"StretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement::StretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MediaPlayerElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MediaPlayerElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MediaPlayerElement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MediaPlayerElement[] = {
        { "set_media_player", reinterpret_cast<PyCFunction>(MediaPlayerElement_SetMediaPlayer), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_MediaPlayerElement, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MediaPlayerElement), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MediaPlayerElement[] = {
        { "transport_controls", reinterpret_cast<getter>(MediaPlayerElement_get_TransportControls), reinterpret_cast<setter>(MediaPlayerElement_put_TransportControls), nullptr, nullptr },
        { "stretch", reinterpret_cast<getter>(MediaPlayerElement_get_Stretch), reinterpret_cast<setter>(MediaPlayerElement_put_Stretch), nullptr, nullptr },
        { "source", reinterpret_cast<getter>(MediaPlayerElement_get_Source), reinterpret_cast<setter>(MediaPlayerElement_put_Source), nullptr, nullptr },
        { "poster_source", reinterpret_cast<getter>(MediaPlayerElement_get_PosterSource), reinterpret_cast<setter>(MediaPlayerElement_put_PosterSource), nullptr, nullptr },
        { "is_full_window", reinterpret_cast<getter>(MediaPlayerElement_get_IsFullWindow), reinterpret_cast<setter>(MediaPlayerElement_put_IsFullWindow), nullptr, nullptr },
        { "auto_play", reinterpret_cast<getter>(MediaPlayerElement_get_AutoPlay), reinterpret_cast<setter>(MediaPlayerElement_put_AutoPlay), nullptr, nullptr },
        { "are_transport_controls_enabled", reinterpret_cast<getter>(MediaPlayerElement_get_AreTransportControlsEnabled), reinterpret_cast<setter>(MediaPlayerElement_put_AreTransportControlsEnabled), nullptr, nullptr },
        { "media_player", reinterpret_cast<getter>(MediaPlayerElement_get_MediaPlayer), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MediaPlayerElement[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MediaPlayerElement) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MediaPlayerElement) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MediaPlayerElement) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MediaPlayerElement) },
        { },
    };

    static PyType_Spec type_spec_MediaPlayerElement =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaPlayerElement",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerElement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MediaPlayerElement
    };

    static PyGetSetDef getset_MediaPlayerElement_Static[] = {
        { "are_transport_controls_enabled_property", reinterpret_cast<getter>(MediaPlayerElement_get_AreTransportControlsEnabledProperty), nullptr, nullptr, nullptr },
        { "auto_play_property", reinterpret_cast<getter>(MediaPlayerElement_get_AutoPlayProperty), nullptr, nullptr, nullptr },
        { "is_full_window_property", reinterpret_cast<getter>(MediaPlayerElement_get_IsFullWindowProperty), nullptr, nullptr, nullptr },
        { "media_player_property", reinterpret_cast<getter>(MediaPlayerElement_get_MediaPlayerProperty), nullptr, nullptr, nullptr },
        { "poster_source_property", reinterpret_cast<getter>(MediaPlayerElement_get_PosterSourceProperty), nullptr, nullptr, nullptr },
        { "source_property", reinterpret_cast<getter>(MediaPlayerElement_get_SourceProperty), nullptr, nullptr, nullptr },
        { "stretch_property", reinterpret_cast<getter>(MediaPlayerElement_get_StretchProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MediaPlayerElement_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MediaPlayerElement_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MediaPlayerElement_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MediaPlayerElement_Static) },
        { }
    };

    static PyType_Spec type_spec_MediaPlayerElement_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaPlayerElement_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MediaPlayerElement_Static
    };

    // ----- MediaPlayerPresenter class --------------------

    static PyObject* _new_MediaPlayerPresenter(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::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter 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_MediaPlayerPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MediaPlayerPresenter_get_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"Stretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Stretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerPresenter_put_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"Stretch"))
        {
            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::Microsoft::UI::Xaml::Media::Stretch>(arg);

            self->obj.Stretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerPresenter_get_MediaPlayer(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"MediaPlayer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MediaPlayer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerPresenter_put_MediaPlayer(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"MediaPlayer"))
        {
            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::Media::Playback::MediaPlayer>(arg);

            self->obj.MediaPlayer(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerPresenter_get_IsFullWindow(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"IsFullWindow"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsFullWindow());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaPlayerPresenter_put_IsFullWindow(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"IsFullWindow"))
        {
            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.IsFullWindow(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaPlayerPresenter_get_IsFullWindowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"IsFullWindowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter::IsFullWindowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerPresenter_get_MediaPlayerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"MediaPlayerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter::MediaPlayerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaPlayerPresenter_get_StretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaPlayerPresenter", L"StretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter::StretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MediaPlayerPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MediaPlayerPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MediaPlayerPresenter[] = {
        { "_assign_array_", _assign_array_MediaPlayerPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MediaPlayerPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MediaPlayerPresenter[] = {
        { "stretch", reinterpret_cast<getter>(MediaPlayerPresenter_get_Stretch), reinterpret_cast<setter>(MediaPlayerPresenter_put_Stretch), nullptr, nullptr },
        { "media_player", reinterpret_cast<getter>(MediaPlayerPresenter_get_MediaPlayer), reinterpret_cast<setter>(MediaPlayerPresenter_put_MediaPlayer), nullptr, nullptr },
        { "is_full_window", reinterpret_cast<getter>(MediaPlayerPresenter_get_IsFullWindow), reinterpret_cast<setter>(MediaPlayerPresenter_put_IsFullWindow), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MediaPlayerPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MediaPlayerPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MediaPlayerPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MediaPlayerPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MediaPlayerPresenter) },
        { },
    };

    static PyType_Spec type_spec_MediaPlayerPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaPlayerPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MediaPlayerPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MediaPlayerPresenter
    };

    static PyGetSetDef getset_MediaPlayerPresenter_Static[] = {
        { "is_full_window_property", reinterpret_cast<getter>(MediaPlayerPresenter_get_IsFullWindowProperty), nullptr, nullptr, nullptr },
        { "media_player_property", reinterpret_cast<getter>(MediaPlayerPresenter_get_MediaPlayerProperty), nullptr, nullptr, nullptr },
        { "stretch_property", reinterpret_cast<getter>(MediaPlayerPresenter_get_StretchProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MediaPlayerPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MediaPlayerPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MediaPlayerPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MediaPlayerPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_MediaPlayerPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaPlayerPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MediaPlayerPresenter_Static
    };

    // ----- MediaTransportControls class --------------------

    static PyObject* _new_MediaTransportControls(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::Microsoft::UI::Xaml::Controls::MediaTransportControls 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_MediaTransportControls(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MediaTransportControls_Hide(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"Hide", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Hide();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_Show(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"Show", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Show();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_ShowAndHideAutomatically(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"ShowAndHideAutomatically"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ShowAndHideAutomatically());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_ShowAndHideAutomatically(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"ShowAndHideAutomatically"))
        {
            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.ShowAndHideAutomatically(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsZoomEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsZoomEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsZoomEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsZoomEnabled"))
        {
            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.IsZoomEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsZoomButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsZoomButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsZoomButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsZoomButtonVisible"))
        {
            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.IsZoomButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsVolumeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsVolumeEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsVolumeEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsVolumeEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsVolumeEnabled"))
        {
            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.IsVolumeEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsVolumeButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsVolumeButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsVolumeButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsVolumeButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsVolumeButtonVisible"))
        {
            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.IsVolumeButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsStopEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsStopEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsStopEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsStopEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsStopEnabled"))
        {
            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.IsStopEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsStopButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsStopButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsStopButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsStopButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsStopButtonVisible"))
        {
            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.IsStopButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipForwardEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipForwardEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSkipForwardEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsSkipForwardEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipForwardEnabled"))
        {
            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.IsSkipForwardEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipForwardButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipForwardButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSkipForwardButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsSkipForwardButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipForwardButtonVisible"))
        {
            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.IsSkipForwardButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipBackwardEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipBackwardEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSkipBackwardEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsSkipBackwardEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipBackwardEnabled"))
        {
            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.IsSkipBackwardEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipBackwardButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipBackwardButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSkipBackwardButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsSkipBackwardButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipBackwardButtonVisible"))
        {
            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.IsSkipBackwardButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsSeekEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSeekEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSeekEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsSeekEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSeekEnabled"))
        {
            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.IsSeekEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsSeekBarVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSeekBarVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSeekBarVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsSeekBarVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSeekBarVisible"))
        {
            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.IsSeekBarVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsRepeatEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsRepeatEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsRepeatEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsRepeatEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsRepeatEnabled"))
        {
            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.IsRepeatEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsRepeatButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsRepeatButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsRepeatButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsRepeatButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsRepeatButtonVisible"))
        {
            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.IsRepeatButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsPreviousTrackButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPreviousTrackButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPreviousTrackButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsPreviousTrackButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPreviousTrackButtonVisible"))
        {
            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.IsPreviousTrackButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsPlaybackRateEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPlaybackRateEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPlaybackRateEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsPlaybackRateEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPlaybackRateEnabled"))
        {
            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.IsPlaybackRateEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsPlaybackRateButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPlaybackRateButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPlaybackRateButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsPlaybackRateButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPlaybackRateButtonVisible"))
        {
            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.IsPlaybackRateButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsNextTrackButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsNextTrackButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsNextTrackButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsNextTrackButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsNextTrackButtonVisible"))
        {
            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.IsNextTrackButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastRewindEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastRewindEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsFastRewindEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsFastRewindEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastRewindEnabled"))
        {
            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.IsFastRewindEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastRewindButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastRewindButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsFastRewindButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsFastRewindButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastRewindButtonVisible"))
        {
            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.IsFastRewindButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastForwardEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastForwardEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsFastForwardEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsFastForwardEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastForwardEnabled"))
        {
            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.IsFastForwardEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastForwardButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastForwardButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsFastForwardButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsFastForwardButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastForwardButtonVisible"))
        {
            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.IsFastForwardButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsCompact"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsCompact());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsCompact"))
        {
            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.IsCompact(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_FastPlayFallbackBehaviour(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"FastPlayFallbackBehaviour"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FastPlayFallbackBehaviour());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MediaTransportControls_put_FastPlayFallbackBehaviour(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"FastPlayFallbackBehaviour"))
        {
            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::Microsoft::UI::Xaml::Media::FastPlayFallbackBehaviour>(arg);

            self->obj.FastPlayFallbackBehaviour(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MediaTransportControls_get_FastPlayFallbackBehaviourProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"FastPlayFallbackBehaviourProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::FastPlayFallbackBehaviourProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsCompactProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsCompactProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsCompactProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastForwardButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastForwardButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsFastForwardButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastForwardEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastForwardEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsFastForwardEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastRewindButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastRewindButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsFastRewindButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsFastRewindEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsFastRewindEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsFastRewindEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsNextTrackButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsNextTrackButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsNextTrackButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsPlaybackRateButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPlaybackRateButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsPlaybackRateButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsPlaybackRateEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPlaybackRateEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsPlaybackRateEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsPreviousTrackButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsPreviousTrackButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsPreviousTrackButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsRepeatButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsRepeatButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsRepeatButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsRepeatEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsRepeatEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsRepeatEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsSeekBarVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSeekBarVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsSeekBarVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsSeekEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSeekEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsSeekEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipBackwardButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipBackwardButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsSkipBackwardButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipBackwardEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipBackwardEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsSkipBackwardEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipForwardButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipForwardButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsSkipForwardButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsSkipForwardEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsSkipForwardEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsSkipForwardEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsStopButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsStopButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsStopButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsStopEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsStopEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsStopEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsVolumeButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsVolumeButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsVolumeButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsVolumeEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsVolumeEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsVolumeEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsZoomButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsZoomButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsZoomButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_IsZoomEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"IsZoomEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::IsZoomEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_get_ShowAndHideAutomaticallyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"ShowAndHideAutomaticallyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls::ShowAndHideAutomaticallyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_add_ThumbnailRequested(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"ThumbnailRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls, winrt::Microsoft::UI::Xaml::Media::MediaTransportControlsThumbnailRequestedEventArgs>>(arg);

            return py::convert(self->obj.ThumbnailRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MediaTransportControls_remove_ThumbnailRequested(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControls", L"ThumbnailRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ThumbnailRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MediaTransportControls(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MediaTransportControls(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MediaTransportControls>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MediaTransportControls[] = {
        { "hide", reinterpret_cast<PyCFunction>(MediaTransportControls_Hide), METH_VARARGS, nullptr },
        { "show", reinterpret_cast<PyCFunction>(MediaTransportControls_Show), METH_VARARGS, nullptr },
        { "add_thumbnail_requested", reinterpret_cast<PyCFunction>(MediaTransportControls_add_ThumbnailRequested), METH_O, nullptr },
        { "remove_thumbnail_requested", reinterpret_cast<PyCFunction>(MediaTransportControls_remove_ThumbnailRequested), METH_O, nullptr },
        { "_assign_array_", _assign_array_MediaTransportControls, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MediaTransportControls), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MediaTransportControls[] = {
        { "show_and_hide_automatically", reinterpret_cast<getter>(MediaTransportControls_get_ShowAndHideAutomatically), reinterpret_cast<setter>(MediaTransportControls_put_ShowAndHideAutomatically), nullptr, nullptr },
        { "is_zoom_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsZoomEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsZoomEnabled), nullptr, nullptr },
        { "is_zoom_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsZoomButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsZoomButtonVisible), nullptr, nullptr },
        { "is_volume_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsVolumeEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsVolumeEnabled), nullptr, nullptr },
        { "is_volume_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsVolumeButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsVolumeButtonVisible), nullptr, nullptr },
        { "is_stop_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsStopEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsStopEnabled), nullptr, nullptr },
        { "is_stop_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsStopButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsStopButtonVisible), nullptr, nullptr },
        { "is_skip_forward_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipForwardEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsSkipForwardEnabled), nullptr, nullptr },
        { "is_skip_forward_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipForwardButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsSkipForwardButtonVisible), nullptr, nullptr },
        { "is_skip_backward_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipBackwardEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsSkipBackwardEnabled), nullptr, nullptr },
        { "is_skip_backward_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipBackwardButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsSkipBackwardButtonVisible), nullptr, nullptr },
        { "is_seek_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsSeekEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsSeekEnabled), nullptr, nullptr },
        { "is_seek_bar_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsSeekBarVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsSeekBarVisible), nullptr, nullptr },
        { "is_repeat_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsRepeatEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsRepeatEnabled), nullptr, nullptr },
        { "is_repeat_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsRepeatButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsRepeatButtonVisible), nullptr, nullptr },
        { "is_previous_track_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsPreviousTrackButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsPreviousTrackButtonVisible), nullptr, nullptr },
        { "is_playback_rate_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsPlaybackRateEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsPlaybackRateEnabled), nullptr, nullptr },
        { "is_playback_rate_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsPlaybackRateButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsPlaybackRateButtonVisible), nullptr, nullptr },
        { "is_next_track_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsNextTrackButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsNextTrackButtonVisible), nullptr, nullptr },
        { "is_fast_rewind_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsFastRewindEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsFastRewindEnabled), nullptr, nullptr },
        { "is_fast_rewind_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsFastRewindButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsFastRewindButtonVisible), nullptr, nullptr },
        { "is_fast_forward_enabled", reinterpret_cast<getter>(MediaTransportControls_get_IsFastForwardEnabled), reinterpret_cast<setter>(MediaTransportControls_put_IsFastForwardEnabled), nullptr, nullptr },
        { "is_fast_forward_button_visible", reinterpret_cast<getter>(MediaTransportControls_get_IsFastForwardButtonVisible), reinterpret_cast<setter>(MediaTransportControls_put_IsFastForwardButtonVisible), nullptr, nullptr },
        { "is_compact", reinterpret_cast<getter>(MediaTransportControls_get_IsCompact), reinterpret_cast<setter>(MediaTransportControls_put_IsCompact), nullptr, nullptr },
        { "fast_play_fallback_behaviour", reinterpret_cast<getter>(MediaTransportControls_get_FastPlayFallbackBehaviour), reinterpret_cast<setter>(MediaTransportControls_put_FastPlayFallbackBehaviour), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MediaTransportControls[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MediaTransportControls) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MediaTransportControls) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MediaTransportControls) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MediaTransportControls) },
        { },
    };

    static PyType_Spec type_spec_MediaTransportControls =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaTransportControls",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControls),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MediaTransportControls
    };

    static PyGetSetDef getset_MediaTransportControls_Static[] = {
        { "fast_play_fallback_behaviour_property", reinterpret_cast<getter>(MediaTransportControls_get_FastPlayFallbackBehaviourProperty), nullptr, nullptr, nullptr },
        { "is_compact_property", reinterpret_cast<getter>(MediaTransportControls_get_IsCompactProperty), nullptr, nullptr, nullptr },
        { "is_fast_forward_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsFastForwardButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_fast_forward_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsFastForwardEnabledProperty), nullptr, nullptr, nullptr },
        { "is_fast_rewind_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsFastRewindButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_fast_rewind_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsFastRewindEnabledProperty), nullptr, nullptr, nullptr },
        { "is_next_track_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsNextTrackButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_playback_rate_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsPlaybackRateButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_playback_rate_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsPlaybackRateEnabledProperty), nullptr, nullptr, nullptr },
        { "is_previous_track_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsPreviousTrackButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_repeat_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsRepeatButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_repeat_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsRepeatEnabledProperty), nullptr, nullptr, nullptr },
        { "is_seek_bar_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsSeekBarVisibleProperty), nullptr, nullptr, nullptr },
        { "is_seek_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsSeekEnabledProperty), nullptr, nullptr, nullptr },
        { "is_skip_backward_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipBackwardButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_skip_backward_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipBackwardEnabledProperty), nullptr, nullptr, nullptr },
        { "is_skip_forward_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipForwardButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_skip_forward_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsSkipForwardEnabledProperty), nullptr, nullptr, nullptr },
        { "is_stop_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsStopButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_stop_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsStopEnabledProperty), nullptr, nullptr, nullptr },
        { "is_volume_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsVolumeButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_volume_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsVolumeEnabledProperty), nullptr, nullptr, nullptr },
        { "is_zoom_button_visible_property", reinterpret_cast<getter>(MediaTransportControls_get_IsZoomButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_zoom_enabled_property", reinterpret_cast<getter>(MediaTransportControls_get_IsZoomEnabledProperty), nullptr, nullptr, nullptr },
        { "show_and_hide_automatically_property", reinterpret_cast<getter>(MediaTransportControls_get_ShowAndHideAutomaticallyProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MediaTransportControls_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MediaTransportControls_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MediaTransportControls_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MediaTransportControls_Static) },
        { }
    };

    static PyType_Spec type_spec_MediaTransportControls_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaTransportControls_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MediaTransportControls_Static
    };

    // ----- MediaTransportControlsHelper class --------------------

    static PyObject* _new_MediaTransportControlsHelper(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper>::type_name);
        return nullptr;
    }

    static void _dealloc_MediaTransportControlsHelper(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MediaTransportControlsHelper_GetDropoutOrder(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControlsHelper", L"GetDropoutOrder", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper::GetDropoutOrder(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* MediaTransportControlsHelper_SetDropoutOrder(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControlsHelper", L"SetDropoutOrder", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<int32_t>>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper::SetDropoutOrder(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* MediaTransportControlsHelper_get_DropoutOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MediaTransportControlsHelper", L"DropoutOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper::DropoutOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MediaTransportControlsHelper(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MediaTransportControlsHelper(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MediaTransportControlsHelper[] = {
        { "_assign_array_", _assign_array_MediaTransportControlsHelper, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MediaTransportControlsHelper), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MediaTransportControlsHelper[] = {
        { }
    };

    static PyType_Slot _type_slots_MediaTransportControlsHelper[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MediaTransportControlsHelper) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MediaTransportControlsHelper) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MediaTransportControlsHelper) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MediaTransportControlsHelper) },
        { },
    };

    static PyType_Spec type_spec_MediaTransportControlsHelper =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaTransportControlsHelper",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MediaTransportControlsHelper),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MediaTransportControlsHelper
    };

    static PyGetSetDef getset_MediaTransportControlsHelper_Static[] = {
        { "dropout_order_property", reinterpret_cast<getter>(MediaTransportControlsHelper_get_DropoutOrderProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MediaTransportControlsHelper_Static[] = {
        { "get_dropout_order", reinterpret_cast<PyCFunction>(MediaTransportControlsHelper_GetDropoutOrder), METH_VARARGS, nullptr },
        { "set_dropout_order", reinterpret_cast<PyCFunction>(MediaTransportControlsHelper_SetDropoutOrder), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_MediaTransportControlsHelper_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MediaTransportControlsHelper_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MediaTransportControlsHelper_Static) },
        { }
    };

    static PyType_Spec type_spec_MediaTransportControlsHelper_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MediaTransportControlsHelper_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MediaTransportControlsHelper_Static
    };

    // ----- MenuBar class --------------------

    static PyObject* _new_MenuBar(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::Microsoft::UI::Xaml::Controls::MenuBar 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_MenuBar(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MenuBar_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuBar", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuBar_get_ItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuBar", L"ItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuBar::ItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MenuBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuBar[] = {
        { "_assign_array_", _assign_array_MenuBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuBar[] = {
        { "items", reinterpret_cast<getter>(MenuBar_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MenuBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuBar) },
        { },
    };

    static PyType_Spec type_spec_MenuBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuBar
    };

    static PyGetSetDef getset_MenuBar_Static[] = {
        { "items_property", reinterpret_cast<getter>(MenuBar_get_ItemsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MenuBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MenuBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MenuBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MenuBar_Static) },
        { }
    };

    static PyType_Spec type_spec_MenuBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MenuBar_Static
    };

    // ----- MenuBarItem class --------------------

    static PyObject* _new_MenuBarItem(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::Microsoft::UI::Xaml::Controls::MenuBarItem 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_MenuBarItem(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBarItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MenuBarItem_get_Title(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBarItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuBarItem", L"Title"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Title());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuBarItem_put_Title(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBarItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuBarItem", L"Title"))
        {
            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.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuBarItem_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBarItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuBarItem", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuBarItem_get_ItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuBarItem", L"ItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuBarItem::ItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuBarItem_get_TitleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuBarItem", L"TitleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuBarItem::TitleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MenuBarItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuBarItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuBarItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuBarItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuBarItem[] = {
        { "_assign_array_", _assign_array_MenuBarItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuBarItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuBarItem[] = {
        { "title", reinterpret_cast<getter>(MenuBarItem_get_Title), reinterpret_cast<setter>(MenuBarItem_put_Title), nullptr, nullptr },
        { "items", reinterpret_cast<getter>(MenuBarItem_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MenuBarItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuBarItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuBarItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuBarItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuBarItem) },
        { },
    };

    static PyType_Spec type_spec_MenuBarItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuBarItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBarItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuBarItem
    };

    static PyGetSetDef getset_MenuBarItem_Static[] = {
        { "items_property", reinterpret_cast<getter>(MenuBarItem_get_ItemsProperty), nullptr, nullptr, nullptr },
        { "title_property", reinterpret_cast<getter>(MenuBarItem_get_TitleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MenuBarItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MenuBarItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MenuBarItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MenuBarItem_Static) },
        { }
    };

    static PyType_Spec type_spec_MenuBarItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuBarItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MenuBarItem_Static
    };

    // ----- MenuBarItemFlyout class --------------------

    static PyObject* _new_MenuBarItemFlyout(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::Microsoft::UI::Xaml::Controls::MenuBarItemFlyout 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_MenuBarItemFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBarItemFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_MenuBarItemFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuBarItemFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuBarItemFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuBarItemFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuBarItemFlyout[] = {
        { "_assign_array_", _assign_array_MenuBarItemFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuBarItemFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuBarItemFlyout[] = {
        { }
    };

    static PyType_Slot _type_slots_MenuBarItemFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuBarItemFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuBarItemFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuBarItemFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuBarItemFlyout) },
        { },
    };

    static PyType_Spec type_spec_MenuBarItemFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuBarItemFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuBarItemFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuBarItemFlyout
    };

    // ----- MenuFlyout class --------------------

    static PyObject* _new_MenuFlyout(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::Microsoft::UI::Xaml::Controls::MenuFlyout 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_MenuFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MenuFlyout_ShowAt(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyout", L"ShowAt", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Point>(args, 1);

                self->obj.ShowAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* MenuFlyout_get_MenuFlyoutPresenterStyle(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyout", L"MenuFlyoutPresenterStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuFlyoutPresenterStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyout_put_MenuFlyoutPresenterStyle(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyout", L"MenuFlyoutPresenterStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.MenuFlyoutPresenterStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyout_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyout", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyout_get_MenuFlyoutPresenterStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyout", L"MenuFlyoutPresenterStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyout::MenuFlyoutPresenterStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MenuFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuFlyout[] = {
        { "show_at", reinterpret_cast<PyCFunction>(MenuFlyout_ShowAt), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_MenuFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuFlyout[] = {
        { "menu_flyout_presenter_style", reinterpret_cast<getter>(MenuFlyout_get_MenuFlyoutPresenterStyle), reinterpret_cast<setter>(MenuFlyout_put_MenuFlyoutPresenterStyle), nullptr, nullptr },
        { "items", reinterpret_cast<getter>(MenuFlyout_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MenuFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuFlyout) },
        { },
    };

    static PyType_Spec type_spec_MenuFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuFlyout
    };

    static PyGetSetDef getset_MenuFlyout_Static[] = {
        { "menu_flyout_presenter_style_property", reinterpret_cast<getter>(MenuFlyout_get_MenuFlyoutPresenterStyleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MenuFlyout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MenuFlyout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MenuFlyout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MenuFlyout_Static) },
        { }
    };

    static PyType_Spec type_spec_MenuFlyout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MenuFlyout_Static
    };

    // ----- MenuFlyoutItem class --------------------

    static PyObject* _new_MenuFlyoutItem(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::Microsoft::UI::Xaml::Controls::MenuFlyoutItem 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_MenuFlyoutItem(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MenuFlyoutItem_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutItem_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutItem_get_KeyboardAcceleratorTextOverride(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"KeyboardAcceleratorTextOverride"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.KeyboardAcceleratorTextOverride());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutItem_put_KeyboardAcceleratorTextOverride(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"KeyboardAcceleratorTextOverride"))
        {
            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.KeyboardAcceleratorTextOverride(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutItem_get_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Icon"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Icon());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutItem_put_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Icon"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.Icon(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutItem_get_CommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"CommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CommandParameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutItem_put_CommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"CommandParameter"))
        {
            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.CommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutItem_get_Command(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Command"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Command());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutItem_put_Command(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Command"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

            self->obj.Command(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutItem_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutItem_get_CommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"CommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItem::CommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutItem_get_CommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"CommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItem::CommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutItem_get_IconProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"IconProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItem::IconProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutItem_get_KeyboardAcceleratorTextOverrideProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"KeyboardAcceleratorTextOverrideProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItem::KeyboardAcceleratorTextOverrideProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutItem_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItem::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutItem_add_Click(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Click"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.Click(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutItem_remove_Click(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutItem", L"Click"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Click(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MenuFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuFlyoutItem[] = {
        { "add_click", reinterpret_cast<PyCFunction>(MenuFlyoutItem_add_Click), METH_O, nullptr },
        { "remove_click", reinterpret_cast<PyCFunction>(MenuFlyoutItem_remove_Click), METH_O, nullptr },
        { "_assign_array_", _assign_array_MenuFlyoutItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuFlyoutItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuFlyoutItem[] = {
        { "text", reinterpret_cast<getter>(MenuFlyoutItem_get_Text), reinterpret_cast<setter>(MenuFlyoutItem_put_Text), nullptr, nullptr },
        { "keyboard_accelerator_text_override", reinterpret_cast<getter>(MenuFlyoutItem_get_KeyboardAcceleratorTextOverride), reinterpret_cast<setter>(MenuFlyoutItem_put_KeyboardAcceleratorTextOverride), nullptr, nullptr },
        { "icon", reinterpret_cast<getter>(MenuFlyoutItem_get_Icon), reinterpret_cast<setter>(MenuFlyoutItem_put_Icon), nullptr, nullptr },
        { "command_parameter", reinterpret_cast<getter>(MenuFlyoutItem_get_CommandParameter), reinterpret_cast<setter>(MenuFlyoutItem_put_CommandParameter), nullptr, nullptr },
        { "command", reinterpret_cast<getter>(MenuFlyoutItem_get_Command), reinterpret_cast<setter>(MenuFlyoutItem_put_Command), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(MenuFlyoutItem_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MenuFlyoutItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuFlyoutItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuFlyoutItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuFlyoutItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuFlyoutItem) },
        { },
    };

    static PyType_Spec type_spec_MenuFlyoutItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuFlyoutItem
    };

    static PyGetSetDef getset_MenuFlyoutItem_Static[] = {
        { "command_parameter_property", reinterpret_cast<getter>(MenuFlyoutItem_get_CommandParameterProperty), nullptr, nullptr, nullptr },
        { "command_property", reinterpret_cast<getter>(MenuFlyoutItem_get_CommandProperty), nullptr, nullptr, nullptr },
        { "icon_property", reinterpret_cast<getter>(MenuFlyoutItem_get_IconProperty), nullptr, nullptr, nullptr },
        { "keyboard_accelerator_text_override_property", reinterpret_cast<getter>(MenuFlyoutItem_get_KeyboardAcceleratorTextOverrideProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(MenuFlyoutItem_get_TextProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MenuFlyoutItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MenuFlyoutItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MenuFlyoutItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MenuFlyoutItem_Static) },
        { }
    };

    static PyType_Spec type_spec_MenuFlyoutItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MenuFlyoutItem_Static
    };

    // ----- MenuFlyoutItemBase class --------------------

    static PyObject* _new_MenuFlyoutItemBase(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItemBase>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItemBase>::type_name);
        return nullptr;
    }

    static void _dealloc_MenuFlyoutItemBase(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItemBase* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_MenuFlyoutItemBase(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItemBase>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuFlyoutItemBase(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutItemBase>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuFlyoutItemBase[] = {
        { "_assign_array_", _assign_array_MenuFlyoutItemBase, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuFlyoutItemBase), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuFlyoutItemBase[] = {
        { }
    };

    static PyType_Slot _type_slots_MenuFlyoutItemBase[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuFlyoutItemBase) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuFlyoutItemBase) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuFlyoutItemBase) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuFlyoutItemBase) },
        { },
    };

    static PyType_Spec type_spec_MenuFlyoutItemBase =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutItemBase",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutItemBase),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuFlyoutItemBase
    };

    // ----- MenuFlyoutPresenter class --------------------

    static PyObject* _new_MenuFlyoutPresenter(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::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter 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_MenuFlyoutPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MenuFlyoutPresenter_get_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsDefaultShadowEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutPresenter_put_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            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.IsDefaultShadowEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutPresenter_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutPresenter_get_SystemBackdrop(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter", L"SystemBackdrop"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SystemBackdrop());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutPresenter_put_SystemBackdrop(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter", L"SystemBackdrop"))
        {
            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::Microsoft::UI::Xaml::Media::SystemBackdrop>(arg);

            self->obj.SystemBackdrop(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutPresenter_get_IsDefaultShadowEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter", L"IsDefaultShadowEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter::IsDefaultShadowEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutPresenter_get_SystemBackdropProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter", L"SystemBackdropProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter::SystemBackdropProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MenuFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuFlyoutPresenter[] = {
        { "_assign_array_", _assign_array_MenuFlyoutPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuFlyoutPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuFlyoutPresenter[] = {
        { "is_default_shadow_enabled", reinterpret_cast<getter>(MenuFlyoutPresenter_get_IsDefaultShadowEnabled), reinterpret_cast<setter>(MenuFlyoutPresenter_put_IsDefaultShadowEnabled), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(MenuFlyoutPresenter_get_TemplateSettings), nullptr, nullptr, nullptr },
        { "system_backdrop", reinterpret_cast<getter>(MenuFlyoutPresenter_get_SystemBackdrop), reinterpret_cast<setter>(MenuFlyoutPresenter_put_SystemBackdrop), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MenuFlyoutPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuFlyoutPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuFlyoutPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuFlyoutPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuFlyoutPresenter) },
        { },
    };

    static PyType_Spec type_spec_MenuFlyoutPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuFlyoutPresenter
    };

    static PyGetSetDef getset_MenuFlyoutPresenter_Static[] = {
        { "is_default_shadow_enabled_property", reinterpret_cast<getter>(MenuFlyoutPresenter_get_IsDefaultShadowEnabledProperty), nullptr, nullptr, nullptr },
        { "system_backdrop_property", reinterpret_cast<getter>(MenuFlyoutPresenter_get_SystemBackdropProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MenuFlyoutPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MenuFlyoutPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MenuFlyoutPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MenuFlyoutPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_MenuFlyoutPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MenuFlyoutPresenter_Static
    };

    // ----- MenuFlyoutSeparator class --------------------

    static PyObject* _new_MenuFlyoutSeparator(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::Microsoft::UI::Xaml::Controls::MenuFlyoutSeparator 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_MenuFlyoutSeparator(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSeparator* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_MenuFlyoutSeparator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSeparator>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuFlyoutSeparator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSeparator>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuFlyoutSeparator[] = {
        { "_assign_array_", _assign_array_MenuFlyoutSeparator, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuFlyoutSeparator), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuFlyoutSeparator[] = {
        { }
    };

    static PyType_Slot _type_slots_MenuFlyoutSeparator[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuFlyoutSeparator) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuFlyoutSeparator) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuFlyoutSeparator) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuFlyoutSeparator) },
        { },
    };

    static PyType_Spec type_spec_MenuFlyoutSeparator =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutSeparator",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSeparator),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuFlyoutSeparator
    };

    // ----- MenuFlyoutSubItem class --------------------

    static PyObject* _new_MenuFlyoutSubItem(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::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem 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_MenuFlyoutSubItem(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* MenuFlyoutSubItem_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutSubItem_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutSubItem_get_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem", L"Icon"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Icon());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int MenuFlyoutSubItem_put_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem", L"Icon"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.Icon(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* MenuFlyoutSubItem_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutSubItem_get_IconProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem", L"IconProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem::IconProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* MenuFlyoutSubItem_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_MenuFlyoutSubItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_MenuFlyoutSubItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_MenuFlyoutSubItem[] = {
        { "_assign_array_", _assign_array_MenuFlyoutSubItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_MenuFlyoutSubItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_MenuFlyoutSubItem[] = {
        { "text", reinterpret_cast<getter>(MenuFlyoutSubItem_get_Text), reinterpret_cast<setter>(MenuFlyoutSubItem_put_Text), nullptr, nullptr },
        { "icon", reinterpret_cast<getter>(MenuFlyoutSubItem_get_Icon), reinterpret_cast<setter>(MenuFlyoutSubItem_put_Icon), nullptr, nullptr },
        { "items", reinterpret_cast<getter>(MenuFlyoutSubItem_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_MenuFlyoutSubItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_MenuFlyoutSubItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_MenuFlyoutSubItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_MenuFlyoutSubItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_MenuFlyoutSubItem) },
        { },
    };

    static PyType_Spec type_spec_MenuFlyoutSubItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutSubItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_MenuFlyoutSubItem
    };

    static PyGetSetDef getset_MenuFlyoutSubItem_Static[] = {
        { "icon_property", reinterpret_cast<getter>(MenuFlyoutSubItem_get_IconProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(MenuFlyoutSubItem_get_TextProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_MenuFlyoutSubItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_MenuFlyoutSubItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_MenuFlyoutSubItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_MenuFlyoutSubItem_Static) },
        { }
    };

    static PyType_Spec type_spec_MenuFlyoutSubItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.MenuFlyoutSubItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_MenuFlyoutSubItem_Static
    };

    // ----- NavigationView class --------------------

    static PyObject* _new_NavigationView(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::Microsoft::UI::Xaml::Controls::NavigationView 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_NavigationView(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationView_Collapse(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Collapse", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem>(args, 0);

                self->obj.Collapse(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* NavigationView_ContainerFromMenuItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ContainerFromMenuItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.ContainerFromMenuItem(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* NavigationView_Expand(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Expand", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem>(args, 0);

                self->obj.Expand(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* NavigationView_MenuItemFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.MenuItemFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectedItem"))
        {
            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.SelectedItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_PaneToggleButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneToggleButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneToggleButtonStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_PaneToggleButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneToggleButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.PaneToggleButtonStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_PaneFooter(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneFooter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneFooter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_PaneFooter(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneFooter"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.PaneFooter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_OpenPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"OpenPaneLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OpenPaneLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_OpenPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"OpenPaneLength"))
        {
            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<double>(arg);

            self->obj.OpenPaneLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_MenuItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_MenuItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemsSource"))
        {
            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.MenuItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_MenuItemContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemContainerStyleSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItemContainerStyleSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_MenuItemContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemContainerStyleSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::StyleSelector>(arg);

            self->obj.MenuItemContainerStyleSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_MenuItemContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemContainerStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItemContainerStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_MenuItemContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemContainerStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.MenuItemContainerStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_IsTitleBarAutoPaddingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsTitleBarAutoPaddingEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTitleBarAutoPaddingEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_IsTitleBarAutoPaddingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsTitleBarAutoPaddingEnabled"))
        {
            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.IsTitleBarAutoPaddingEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_IsSettingsVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsSettingsVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSettingsVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_IsSettingsVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsSettingsVisible"))
        {
            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.IsSettingsVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_IsPaneToggleButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneToggleButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPaneToggleButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_IsPaneToggleButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneToggleButtonVisible"))
        {
            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.IsPaneToggleButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_IsPaneOpen(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPaneOpen());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_IsPaneOpen(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneOpen"))
        {
            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.IsPaneOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_FooterMenuItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"FooterMenuItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FooterMenuItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_FooterMenuItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"FooterMenuItemsSource"))
        {
            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.FooterMenuItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_MenuItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItemTemplateSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_MenuItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

            self->obj.MenuItemTemplateSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_ExpandedModeThresholdWidth(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ExpandedModeThresholdWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExpandedModeThresholdWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_ExpandedModeThresholdWidth(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ExpandedModeThresholdWidth"))
        {
            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<double>(arg);

            self->obj.ExpandedModeThresholdWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_MenuItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_MenuItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.MenuItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_CompactPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"CompactPaneLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CompactPaneLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_CompactPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"CompactPaneLength"))
        {
            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<double>(arg);

            self->obj.CompactPaneLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_CompactModeThresholdWidth(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"CompactModeThresholdWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CompactModeThresholdWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_CompactModeThresholdWidth(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"CompactModeThresholdWidth"))
        {
            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<double>(arg);

            self->obj.CompactModeThresholdWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_AutoSuggestBox(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"AutoSuggestBox"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AutoSuggestBox());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_AutoSuggestBox(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"AutoSuggestBox"))
        {
            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::Microsoft::UI::Xaml::Controls::AutoSuggestBox>(arg);

            self->obj.AutoSuggestBox(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_AlwaysShowHeader(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"AlwaysShowHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AlwaysShowHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_AlwaysShowHeader(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"AlwaysShowHeader"))
        {
            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.AlwaysShowHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_MenuItems(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"DisplayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisplayMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_FooterMenuItems(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"FooterMenuItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FooterMenuItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_SettingsItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SettingsItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SettingsItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_ShoulderNavigationEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ShoulderNavigationEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ShoulderNavigationEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_ShoulderNavigationEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ShoulderNavigationEnabled"))
        {
            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::Microsoft::UI::Xaml::Controls::NavigationViewShoulderNavigationEnabled>(arg);

            self->obj.ShoulderNavigationEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_SelectionFollowsFocus(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectionFollowsFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionFollowsFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_SelectionFollowsFocus(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectionFollowsFocus"))
        {
            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::Microsoft::UI::Xaml::Controls::NavigationViewSelectionFollowsFocus>(arg);

            self->obj.SelectionFollowsFocus(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_PaneTitle(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneTitle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneTitle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_PaneTitle(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneTitle"))
        {
            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.PaneTitle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_PaneHeader(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_PaneHeader(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneHeader"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.PaneHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_PaneDisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneDisplayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneDisplayMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_PaneDisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneDisplayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::NavigationViewPaneDisplayMode>(arg);

            self->obj.PaneDisplayMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_PaneCustomContent(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneCustomContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneCustomContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_PaneCustomContent(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneCustomContent"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.PaneCustomContent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_OverflowLabelMode(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"OverflowLabelMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OverflowLabelMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_OverflowLabelMode(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"OverflowLabelMode"))
        {
            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::Microsoft::UI::Xaml::Controls::NavigationViewOverflowLabelMode>(arg);

            self->obj.OverflowLabelMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_IsPaneVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPaneVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_IsPaneVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneVisible"))
        {
            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.IsPaneVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_IsBackEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsBackEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsBackEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_IsBackEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsBackEnabled"))
        {
            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.IsBackEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_IsBackButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsBackButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsBackButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_IsBackButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsBackButtonVisible"))
        {
            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::Microsoft::UI::Xaml::Controls::NavigationViewBackButtonVisible>(arg);

            self->obj.IsBackButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_ContentOverlay(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ContentOverlay"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentOverlay());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationView_put_ContentOverlay(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ContentOverlay"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.ContentOverlay(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationView_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_FooterMenuItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"FooterMenuItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::FooterMenuItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_IsTitleBarAutoPaddingEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsTitleBarAutoPaddingEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::IsTitleBarAutoPaddingEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_MenuItemContainerStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemContainerStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::MenuItemContainerStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_MenuItemContainerStyleSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemContainerStyleSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::MenuItemContainerStyleSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_MenuItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::MenuItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_MenuItemTemplateSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemTemplateSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::MenuItemTemplateSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_MenuItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::MenuItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_MenuItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"MenuItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::MenuItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_OpenPaneLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"OpenPaneLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::OpenPaneLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_PaneFooterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneFooterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::PaneFooterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_PaneToggleButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneToggleButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::PaneToggleButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_AlwaysShowHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"AlwaysShowHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::AlwaysShowHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_AutoSuggestBoxProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"AutoSuggestBoxProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::AutoSuggestBoxProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_CompactModeThresholdWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"CompactModeThresholdWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::CompactModeThresholdWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_CompactPaneLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"CompactPaneLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::CompactPaneLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_DisplayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"DisplayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::DisplayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_ExpandedModeThresholdWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ExpandedModeThresholdWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::ExpandedModeThresholdWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_SettingsItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SettingsItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::SettingsItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_FooterMenuItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"FooterMenuItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::FooterMenuItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_IsPaneOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::IsPaneOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_IsPaneToggleButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneToggleButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::IsPaneToggleButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_IsSettingsVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsSettingsVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::IsSettingsVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_IsBackButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsBackButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::IsBackButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_IsBackEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsBackEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::IsBackEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_IsPaneVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"IsPaneVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::IsPaneVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_OverflowLabelModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"OverflowLabelModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::OverflowLabelModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_PaneCustomContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneCustomContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::PaneCustomContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_PaneDisplayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneDisplayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::PaneDisplayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_PaneHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::PaneHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_PaneTitleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneTitleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::PaneTitleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_SelectionFollowsFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectionFollowsFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::SelectionFollowsFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_ShoulderNavigationEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ShoulderNavigationEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::ShoulderNavigationEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_TemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"TemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::TemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_get_ContentOverlayProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ContentOverlayProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationView::ContentOverlayProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_DisplayModeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"DisplayModeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs>>(arg);

            return py::convert(self->obj.DisplayModeChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_DisplayModeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"DisplayModeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.DisplayModeChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_ItemInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ItemInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs>>(arg);

            return py::convert(self->obj.ItemInvoked(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_ItemInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"ItemInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemInvoked(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs>>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_BackRequested(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"BackRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs>>(arg);

            return py::convert(self->obj.BackRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_BackRequested(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"BackRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.BackRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_Collapsed(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Collapsed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs>>(arg);

            return py::convert(self->obj.Collapsed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_Collapsed(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Collapsed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Collapsed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_Expanding(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Expanding"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs>>(arg);

            return py::convert(self->obj.Expanding(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_Expanding(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"Expanding"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Expanding(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_PaneClosed(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneClosed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PaneClosed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_PaneClosed(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneClosed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneClosed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_PaneClosing(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneClosing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs>>(arg);

            return py::convert(self->obj.PaneClosing(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_PaneClosing(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneClosing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneClosing(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_PaneOpened(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PaneOpened(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_PaneOpened(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneOpened(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_add_PaneOpening(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NavigationView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PaneOpening(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationView_remove_PaneOpening(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NavigationView", L"PaneOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneOpening(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationView[] = {
        { "collapse", reinterpret_cast<PyCFunction>(NavigationView_Collapse), METH_VARARGS, nullptr },
        { "container_from_menu_item", reinterpret_cast<PyCFunction>(NavigationView_ContainerFromMenuItem), METH_VARARGS, nullptr },
        { "expand", reinterpret_cast<PyCFunction>(NavigationView_Expand), METH_VARARGS, nullptr },
        { "menu_item_from_container", reinterpret_cast<PyCFunction>(NavigationView_MenuItemFromContainer), METH_VARARGS, nullptr },
        { "add_display_mode_changed", reinterpret_cast<PyCFunction>(NavigationView_add_DisplayModeChanged), METH_O, nullptr },
        { "remove_display_mode_changed", reinterpret_cast<PyCFunction>(NavigationView_remove_DisplayModeChanged), METH_O, nullptr },
        { "add_item_invoked", reinterpret_cast<PyCFunction>(NavigationView_add_ItemInvoked), METH_O, nullptr },
        { "remove_item_invoked", reinterpret_cast<PyCFunction>(NavigationView_remove_ItemInvoked), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(NavigationView_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(NavigationView_remove_SelectionChanged), METH_O, nullptr },
        { "add_back_requested", reinterpret_cast<PyCFunction>(NavigationView_add_BackRequested), METH_O, nullptr },
        { "remove_back_requested", reinterpret_cast<PyCFunction>(NavigationView_remove_BackRequested), METH_O, nullptr },
        { "add_collapsed", reinterpret_cast<PyCFunction>(NavigationView_add_Collapsed), METH_O, nullptr },
        { "remove_collapsed", reinterpret_cast<PyCFunction>(NavigationView_remove_Collapsed), METH_O, nullptr },
        { "add_expanding", reinterpret_cast<PyCFunction>(NavigationView_add_Expanding), METH_O, nullptr },
        { "remove_expanding", reinterpret_cast<PyCFunction>(NavigationView_remove_Expanding), METH_O, nullptr },
        { "add_pane_closed", reinterpret_cast<PyCFunction>(NavigationView_add_PaneClosed), METH_O, nullptr },
        { "remove_pane_closed", reinterpret_cast<PyCFunction>(NavigationView_remove_PaneClosed), METH_O, nullptr },
        { "add_pane_closing", reinterpret_cast<PyCFunction>(NavigationView_add_PaneClosing), METH_O, nullptr },
        { "remove_pane_closing", reinterpret_cast<PyCFunction>(NavigationView_remove_PaneClosing), METH_O, nullptr },
        { "add_pane_opened", reinterpret_cast<PyCFunction>(NavigationView_add_PaneOpened), METH_O, nullptr },
        { "remove_pane_opened", reinterpret_cast<PyCFunction>(NavigationView_remove_PaneOpened), METH_O, nullptr },
        { "add_pane_opening", reinterpret_cast<PyCFunction>(NavigationView_add_PaneOpening), METH_O, nullptr },
        { "remove_pane_opening", reinterpret_cast<PyCFunction>(NavigationView_remove_PaneOpening), METH_O, nullptr },
        { "_assign_array_", _assign_array_NavigationView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationView[] = {
        { "selected_item", reinterpret_cast<getter>(NavigationView_get_SelectedItem), reinterpret_cast<setter>(NavigationView_put_SelectedItem), nullptr, nullptr },
        { "pane_toggle_button_style", reinterpret_cast<getter>(NavigationView_get_PaneToggleButtonStyle), reinterpret_cast<setter>(NavigationView_put_PaneToggleButtonStyle), nullptr, nullptr },
        { "pane_footer", reinterpret_cast<getter>(NavigationView_get_PaneFooter), reinterpret_cast<setter>(NavigationView_put_PaneFooter), nullptr, nullptr },
        { "open_pane_length", reinterpret_cast<getter>(NavigationView_get_OpenPaneLength), reinterpret_cast<setter>(NavigationView_put_OpenPaneLength), nullptr, nullptr },
        { "menu_items_source", reinterpret_cast<getter>(NavigationView_get_MenuItemsSource), reinterpret_cast<setter>(NavigationView_put_MenuItemsSource), nullptr, nullptr },
        { "menu_item_container_style_selector", reinterpret_cast<getter>(NavigationView_get_MenuItemContainerStyleSelector), reinterpret_cast<setter>(NavigationView_put_MenuItemContainerStyleSelector), nullptr, nullptr },
        { "menu_item_container_style", reinterpret_cast<getter>(NavigationView_get_MenuItemContainerStyle), reinterpret_cast<setter>(NavigationView_put_MenuItemContainerStyle), nullptr, nullptr },
        { "is_title_bar_auto_padding_enabled", reinterpret_cast<getter>(NavigationView_get_IsTitleBarAutoPaddingEnabled), reinterpret_cast<setter>(NavigationView_put_IsTitleBarAutoPaddingEnabled), nullptr, nullptr },
        { "is_settings_visible", reinterpret_cast<getter>(NavigationView_get_IsSettingsVisible), reinterpret_cast<setter>(NavigationView_put_IsSettingsVisible), nullptr, nullptr },
        { "is_pane_toggle_button_visible", reinterpret_cast<getter>(NavigationView_get_IsPaneToggleButtonVisible), reinterpret_cast<setter>(NavigationView_put_IsPaneToggleButtonVisible), nullptr, nullptr },
        { "is_pane_open", reinterpret_cast<getter>(NavigationView_get_IsPaneOpen), reinterpret_cast<setter>(NavigationView_put_IsPaneOpen), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(NavigationView_get_HeaderTemplate), reinterpret_cast<setter>(NavigationView_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(NavigationView_get_Header), reinterpret_cast<setter>(NavigationView_put_Header), nullptr, nullptr },
        { "footer_menu_items_source", reinterpret_cast<getter>(NavigationView_get_FooterMenuItemsSource), reinterpret_cast<setter>(NavigationView_put_FooterMenuItemsSource), nullptr, nullptr },
        { "menu_item_template_selector", reinterpret_cast<getter>(NavigationView_get_MenuItemTemplateSelector), reinterpret_cast<setter>(NavigationView_put_MenuItemTemplateSelector), nullptr, nullptr },
        { "expanded_mode_threshold_width", reinterpret_cast<getter>(NavigationView_get_ExpandedModeThresholdWidth), reinterpret_cast<setter>(NavigationView_put_ExpandedModeThresholdWidth), nullptr, nullptr },
        { "menu_item_template", reinterpret_cast<getter>(NavigationView_get_MenuItemTemplate), reinterpret_cast<setter>(NavigationView_put_MenuItemTemplate), nullptr, nullptr },
        { "compact_pane_length", reinterpret_cast<getter>(NavigationView_get_CompactPaneLength), reinterpret_cast<setter>(NavigationView_put_CompactPaneLength), nullptr, nullptr },
        { "compact_mode_threshold_width", reinterpret_cast<getter>(NavigationView_get_CompactModeThresholdWidth), reinterpret_cast<setter>(NavigationView_put_CompactModeThresholdWidth), nullptr, nullptr },
        { "auto_suggest_box", reinterpret_cast<getter>(NavigationView_get_AutoSuggestBox), reinterpret_cast<setter>(NavigationView_put_AutoSuggestBox), nullptr, nullptr },
        { "always_show_header", reinterpret_cast<getter>(NavigationView_get_AlwaysShowHeader), reinterpret_cast<setter>(NavigationView_put_AlwaysShowHeader), nullptr, nullptr },
        { "menu_items", reinterpret_cast<getter>(NavigationView_get_MenuItems), nullptr, nullptr, nullptr },
        { "display_mode", reinterpret_cast<getter>(NavigationView_get_DisplayMode), nullptr, nullptr, nullptr },
        { "footer_menu_items", reinterpret_cast<getter>(NavigationView_get_FooterMenuItems), nullptr, nullptr, nullptr },
        { "settings_item", reinterpret_cast<getter>(NavigationView_get_SettingsItem), nullptr, nullptr, nullptr },
        { "shoulder_navigation_enabled", reinterpret_cast<getter>(NavigationView_get_ShoulderNavigationEnabled), reinterpret_cast<setter>(NavigationView_put_ShoulderNavigationEnabled), nullptr, nullptr },
        { "selection_follows_focus", reinterpret_cast<getter>(NavigationView_get_SelectionFollowsFocus), reinterpret_cast<setter>(NavigationView_put_SelectionFollowsFocus), nullptr, nullptr },
        { "pane_title", reinterpret_cast<getter>(NavigationView_get_PaneTitle), reinterpret_cast<setter>(NavigationView_put_PaneTitle), nullptr, nullptr },
        { "pane_header", reinterpret_cast<getter>(NavigationView_get_PaneHeader), reinterpret_cast<setter>(NavigationView_put_PaneHeader), nullptr, nullptr },
        { "pane_display_mode", reinterpret_cast<getter>(NavigationView_get_PaneDisplayMode), reinterpret_cast<setter>(NavigationView_put_PaneDisplayMode), nullptr, nullptr },
        { "pane_custom_content", reinterpret_cast<getter>(NavigationView_get_PaneCustomContent), reinterpret_cast<setter>(NavigationView_put_PaneCustomContent), nullptr, nullptr },
        { "overflow_label_mode", reinterpret_cast<getter>(NavigationView_get_OverflowLabelMode), reinterpret_cast<setter>(NavigationView_put_OverflowLabelMode), nullptr, nullptr },
        { "is_pane_visible", reinterpret_cast<getter>(NavigationView_get_IsPaneVisible), reinterpret_cast<setter>(NavigationView_put_IsPaneVisible), nullptr, nullptr },
        { "is_back_enabled", reinterpret_cast<getter>(NavigationView_get_IsBackEnabled), reinterpret_cast<setter>(NavigationView_put_IsBackEnabled), nullptr, nullptr },
        { "is_back_button_visible", reinterpret_cast<getter>(NavigationView_get_IsBackButtonVisible), reinterpret_cast<setter>(NavigationView_put_IsBackButtonVisible), nullptr, nullptr },
        { "content_overlay", reinterpret_cast<getter>(NavigationView_get_ContentOverlay), reinterpret_cast<setter>(NavigationView_put_ContentOverlay), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(NavigationView_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationView) },
        { },
    };

    static PyType_Spec type_spec_NavigationView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationView
    };

    static PyGetSetDef getset_NavigationView_Static[] = {
        { "footer_menu_items_property", reinterpret_cast<getter>(NavigationView_get_FooterMenuItemsProperty), nullptr, nullptr, nullptr },
        { "is_title_bar_auto_padding_enabled_property", reinterpret_cast<getter>(NavigationView_get_IsTitleBarAutoPaddingEnabledProperty), nullptr, nullptr, nullptr },
        { "menu_item_container_style_property", reinterpret_cast<getter>(NavigationView_get_MenuItemContainerStyleProperty), nullptr, nullptr, nullptr },
        { "menu_item_container_style_selector_property", reinterpret_cast<getter>(NavigationView_get_MenuItemContainerStyleSelectorProperty), nullptr, nullptr, nullptr },
        { "menu_item_template_property", reinterpret_cast<getter>(NavigationView_get_MenuItemTemplateProperty), nullptr, nullptr, nullptr },
        { "menu_item_template_selector_property", reinterpret_cast<getter>(NavigationView_get_MenuItemTemplateSelectorProperty), nullptr, nullptr, nullptr },
        { "menu_items_property", reinterpret_cast<getter>(NavigationView_get_MenuItemsProperty), nullptr, nullptr, nullptr },
        { "menu_items_source_property", reinterpret_cast<getter>(NavigationView_get_MenuItemsSourceProperty), nullptr, nullptr, nullptr },
        { "open_pane_length_property", reinterpret_cast<getter>(NavigationView_get_OpenPaneLengthProperty), nullptr, nullptr, nullptr },
        { "pane_footer_property", reinterpret_cast<getter>(NavigationView_get_PaneFooterProperty), nullptr, nullptr, nullptr },
        { "pane_toggle_button_style_property", reinterpret_cast<getter>(NavigationView_get_PaneToggleButtonStyleProperty), nullptr, nullptr, nullptr },
        { "selected_item_property", reinterpret_cast<getter>(NavigationView_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { "always_show_header_property", reinterpret_cast<getter>(NavigationView_get_AlwaysShowHeaderProperty), nullptr, nullptr, nullptr },
        { "auto_suggest_box_property", reinterpret_cast<getter>(NavigationView_get_AutoSuggestBoxProperty), nullptr, nullptr, nullptr },
        { "compact_mode_threshold_width_property", reinterpret_cast<getter>(NavigationView_get_CompactModeThresholdWidthProperty), nullptr, nullptr, nullptr },
        { "compact_pane_length_property", reinterpret_cast<getter>(NavigationView_get_CompactPaneLengthProperty), nullptr, nullptr, nullptr },
        { "display_mode_property", reinterpret_cast<getter>(NavigationView_get_DisplayModeProperty), nullptr, nullptr, nullptr },
        { "expanded_mode_threshold_width_property", reinterpret_cast<getter>(NavigationView_get_ExpandedModeThresholdWidthProperty), nullptr, nullptr, nullptr },
        { "settings_item_property", reinterpret_cast<getter>(NavigationView_get_SettingsItemProperty), nullptr, nullptr, nullptr },
        { "footer_menu_items_source_property", reinterpret_cast<getter>(NavigationView_get_FooterMenuItemsSourceProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(NavigationView_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(NavigationView_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_pane_open_property", reinterpret_cast<getter>(NavigationView_get_IsPaneOpenProperty), nullptr, nullptr, nullptr },
        { "is_pane_toggle_button_visible_property", reinterpret_cast<getter>(NavigationView_get_IsPaneToggleButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_settings_visible_property", reinterpret_cast<getter>(NavigationView_get_IsSettingsVisibleProperty), nullptr, nullptr, nullptr },
        { "is_back_button_visible_property", reinterpret_cast<getter>(NavigationView_get_IsBackButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "is_back_enabled_property", reinterpret_cast<getter>(NavigationView_get_IsBackEnabledProperty), nullptr, nullptr, nullptr },
        { "is_pane_visible_property", reinterpret_cast<getter>(NavigationView_get_IsPaneVisibleProperty), nullptr, nullptr, nullptr },
        { "overflow_label_mode_property", reinterpret_cast<getter>(NavigationView_get_OverflowLabelModeProperty), nullptr, nullptr, nullptr },
        { "pane_custom_content_property", reinterpret_cast<getter>(NavigationView_get_PaneCustomContentProperty), nullptr, nullptr, nullptr },
        { "pane_display_mode_property", reinterpret_cast<getter>(NavigationView_get_PaneDisplayModeProperty), nullptr, nullptr, nullptr },
        { "pane_header_property", reinterpret_cast<getter>(NavigationView_get_PaneHeaderProperty), nullptr, nullptr, nullptr },
        { "pane_title_property", reinterpret_cast<getter>(NavigationView_get_PaneTitleProperty), nullptr, nullptr, nullptr },
        { "selection_follows_focus_property", reinterpret_cast<getter>(NavigationView_get_SelectionFollowsFocusProperty), nullptr, nullptr, nullptr },
        { "shoulder_navigation_enabled_property", reinterpret_cast<getter>(NavigationView_get_ShoulderNavigationEnabledProperty), nullptr, nullptr, nullptr },
        { "template_settings_property", reinterpret_cast<getter>(NavigationView_get_TemplateSettingsProperty), nullptr, nullptr, nullptr },
        { "content_overlay_property", reinterpret_cast<getter>(NavigationView_get_ContentOverlayProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_NavigationView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_NavigationView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_NavigationView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_NavigationView_Static) },
        { }
    };

    static PyType_Spec type_spec_NavigationView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_NavigationView_Static
    };

    // ----- NavigationViewBackRequestedEventArgs class --------------------

    static PyObject* _new_NavigationViewBackRequestedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_NavigationViewBackRequestedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_NavigationViewBackRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewBackRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewBackRequestedEventArgs[] = {
        { "_assign_array_", _assign_array_NavigationViewBackRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewBackRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewBackRequestedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_NavigationViewBackRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewBackRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewBackRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewBackRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewBackRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewBackRequestedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewBackRequestedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewBackRequestedEventArgs
    };

    // ----- NavigationViewDisplayModeChangedEventArgs class --------------------

    static PyObject* _new_NavigationViewDisplayModeChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_NavigationViewDisplayModeChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewDisplayModeChangedEventArgs_get_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs", L"DisplayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisplayMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewDisplayModeChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewDisplayModeChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewDisplayModeChangedEventArgs[] = {
        { "_assign_array_", _assign_array_NavigationViewDisplayModeChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewDisplayModeChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewDisplayModeChangedEventArgs[] = {
        { "display_mode", reinterpret_cast<getter>(NavigationViewDisplayModeChangedEventArgs_get_DisplayMode), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewDisplayModeChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewDisplayModeChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewDisplayModeChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewDisplayModeChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewDisplayModeChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewDisplayModeChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewDisplayModeChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewDisplayModeChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewDisplayModeChangedEventArgs
    };

    // ----- NavigationViewItem class --------------------

    static PyObject* _new_NavigationViewItem(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::Microsoft::UI::Xaml::Controls::NavigationViewItem 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_NavigationViewItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewItem_get_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"Icon"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Icon());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItem_put_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"Icon"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.Icon(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItem_get_CompactPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"CompactPaneLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CompactPaneLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_SelectsOnInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"SelectsOnInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectsOnInvoked());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItem_put_SelectsOnInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"SelectsOnInvoked"))
        {
            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.SelectsOnInvoked(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItem_get_MenuItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"MenuItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItem_put_MenuItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"MenuItemsSource"))
        {
            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.MenuItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItem_get_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"IsExpanded"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsExpanded());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItem_put_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"IsExpanded"))
        {
            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.IsExpanded(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItem_get_IsChildSelected(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"IsChildSelected"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsChildSelected());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItem_put_IsChildSelected(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"IsChildSelected"))
        {
            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.IsChildSelected(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItem_get_HasUnrealizedChildren(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"HasUnrealizedChildren"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasUnrealizedChildren());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItem_put_HasUnrealizedChildren(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"HasUnrealizedChildren"))
        {
            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.HasUnrealizedChildren(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItem_get_MenuItems(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"MenuItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MenuItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_InfoBadge(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"InfoBadge"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InfoBadge());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItem_put_InfoBadge(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"InfoBadge"))
        {
            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::Microsoft::UI::Xaml::Controls::InfoBadge>(arg);

            self->obj.InfoBadge(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItem_get_CompactPaneLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"CompactPaneLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::CompactPaneLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_IconProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"IconProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::IconProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_HasUnrealizedChildrenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"HasUnrealizedChildrenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::HasUnrealizedChildrenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_IsChildSelectedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"IsChildSelectedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::IsChildSelectedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_IsExpandedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"IsExpandedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::IsExpandedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_MenuItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"MenuItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::MenuItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_MenuItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"MenuItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::MenuItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_SelectsOnInvokedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"SelectsOnInvokedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::SelectsOnInvokedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItem_get_InfoBadgeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItem", L"InfoBadgeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem::InfoBadgeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewItem[] = {
        { "_assign_array_", _assign_array_NavigationViewItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewItem[] = {
        { "icon", reinterpret_cast<getter>(NavigationViewItem_get_Icon), reinterpret_cast<setter>(NavigationViewItem_put_Icon), nullptr, nullptr },
        { "compact_pane_length", reinterpret_cast<getter>(NavigationViewItem_get_CompactPaneLength), nullptr, nullptr, nullptr },
        { "selects_on_invoked", reinterpret_cast<getter>(NavigationViewItem_get_SelectsOnInvoked), reinterpret_cast<setter>(NavigationViewItem_put_SelectsOnInvoked), nullptr, nullptr },
        { "menu_items_source", reinterpret_cast<getter>(NavigationViewItem_get_MenuItemsSource), reinterpret_cast<setter>(NavigationViewItem_put_MenuItemsSource), nullptr, nullptr },
        { "is_expanded", reinterpret_cast<getter>(NavigationViewItem_get_IsExpanded), reinterpret_cast<setter>(NavigationViewItem_put_IsExpanded), nullptr, nullptr },
        { "is_child_selected", reinterpret_cast<getter>(NavigationViewItem_get_IsChildSelected), reinterpret_cast<setter>(NavigationViewItem_put_IsChildSelected), nullptr, nullptr },
        { "has_unrealized_children", reinterpret_cast<getter>(NavigationViewItem_get_HasUnrealizedChildren), reinterpret_cast<setter>(NavigationViewItem_put_HasUnrealizedChildren), nullptr, nullptr },
        { "menu_items", reinterpret_cast<getter>(NavigationViewItem_get_MenuItems), nullptr, nullptr, nullptr },
        { "info_badge", reinterpret_cast<getter>(NavigationViewItem_get_InfoBadge), reinterpret_cast<setter>(NavigationViewItem_put_InfoBadge), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewItem) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewItem
    };

    static PyGetSetDef getset_NavigationViewItem_Static[] = {
        { "compact_pane_length_property", reinterpret_cast<getter>(NavigationViewItem_get_CompactPaneLengthProperty), nullptr, nullptr, nullptr },
        { "icon_property", reinterpret_cast<getter>(NavigationViewItem_get_IconProperty), nullptr, nullptr, nullptr },
        { "has_unrealized_children_property", reinterpret_cast<getter>(NavigationViewItem_get_HasUnrealizedChildrenProperty), nullptr, nullptr, nullptr },
        { "is_child_selected_property", reinterpret_cast<getter>(NavigationViewItem_get_IsChildSelectedProperty), nullptr, nullptr, nullptr },
        { "is_expanded_property", reinterpret_cast<getter>(NavigationViewItem_get_IsExpandedProperty), nullptr, nullptr, nullptr },
        { "menu_items_property", reinterpret_cast<getter>(NavigationViewItem_get_MenuItemsProperty), nullptr, nullptr, nullptr },
        { "menu_items_source_property", reinterpret_cast<getter>(NavigationViewItem_get_MenuItemsSourceProperty), nullptr, nullptr, nullptr },
        { "selects_on_invoked_property", reinterpret_cast<getter>(NavigationViewItem_get_SelectsOnInvokedProperty), nullptr, nullptr, nullptr },
        { "info_badge_property", reinterpret_cast<getter>(NavigationViewItem_get_InfoBadgeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_NavigationViewItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_NavigationViewItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_NavigationViewItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_NavigationViewItem_Static) },
        { }
    };

    static PyType_Spec type_spec_NavigationViewItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_NavigationViewItem_Static
    };

    // ----- NavigationViewItemBase class --------------------

    static PyObject* _new_NavigationViewItemBase(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemBase>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemBase>::type_name);
        return nullptr;
    }

    static void _dealloc_NavigationViewItemBase(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemBase* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewItemBase_get_IsSelected(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemBase* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemBase", L"IsSelected"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSelected());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewItemBase_put_IsSelected(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemBase* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemBase", L"IsSelected"))
        {
            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.IsSelected(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NavigationViewItemBase_get_IsSelectedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemBase", L"IsSelectedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemBase::IsSelectedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewItemBase(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemBase>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewItemBase(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemBase>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewItemBase[] = {
        { "_assign_array_", _assign_array_NavigationViewItemBase, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewItemBase), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewItemBase[] = {
        { "is_selected", reinterpret_cast<getter>(NavigationViewItemBase_get_IsSelected), reinterpret_cast<setter>(NavigationViewItemBase_put_IsSelected), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewItemBase[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewItemBase) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewItemBase) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewItemBase) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewItemBase) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewItemBase =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItemBase",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemBase),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewItemBase
    };

    static PyGetSetDef getset_NavigationViewItemBase_Static[] = {
        { "is_selected_property", reinterpret_cast<getter>(NavigationViewItemBase_get_IsSelectedProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_NavigationViewItemBase_Static[] = {
        { }
    };

    static PyType_Slot type_slots_NavigationViewItemBase_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_NavigationViewItemBase_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_NavigationViewItemBase_Static) },
        { }
    };

    static PyType_Spec type_spec_NavigationViewItemBase_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItemBase_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_NavigationViewItemBase_Static
    };

    // ----- NavigationViewItemCollapsedEventArgs class --------------------

    static PyObject* _new_NavigationViewItemCollapsedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_NavigationViewItemCollapsedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewItemCollapsedEventArgs_get_CollapsedItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemCollapsedEventArgs", L"CollapsedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CollapsedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItemCollapsedEventArgs_get_CollapsedItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemCollapsedEventArgs", L"CollapsedItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CollapsedItemContainer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewItemCollapsedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewItemCollapsedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewItemCollapsedEventArgs[] = {
        { "_assign_array_", _assign_array_NavigationViewItemCollapsedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewItemCollapsedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewItemCollapsedEventArgs[] = {
        { "collapsed_item", reinterpret_cast<getter>(NavigationViewItemCollapsedEventArgs_get_CollapsedItem), nullptr, nullptr, nullptr },
        { "collapsed_item_container", reinterpret_cast<getter>(NavigationViewItemCollapsedEventArgs_get_CollapsedItemContainer), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewItemCollapsedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewItemCollapsedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewItemCollapsedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewItemCollapsedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewItemCollapsedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewItemCollapsedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItemCollapsedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemCollapsedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewItemCollapsedEventArgs
    };

    // ----- NavigationViewItemExpandingEventArgs class --------------------

    static PyObject* _new_NavigationViewItemExpandingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_NavigationViewItemExpandingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewItemExpandingEventArgs_get_ExpandingItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemExpandingEventArgs", L"ExpandingItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExpandingItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItemExpandingEventArgs_get_ExpandingItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemExpandingEventArgs", L"ExpandingItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExpandingItemContainer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewItemExpandingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewItemExpandingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewItemExpandingEventArgs[] = {
        { "_assign_array_", _assign_array_NavigationViewItemExpandingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewItemExpandingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewItemExpandingEventArgs[] = {
        { "expanding_item", reinterpret_cast<getter>(NavigationViewItemExpandingEventArgs_get_ExpandingItem), nullptr, nullptr, nullptr },
        { "expanding_item_container", reinterpret_cast<getter>(NavigationViewItemExpandingEventArgs_get_ExpandingItemContainer), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewItemExpandingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewItemExpandingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewItemExpandingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewItemExpandingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewItemExpandingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewItemExpandingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItemExpandingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemExpandingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewItemExpandingEventArgs
    };

    // ----- NavigationViewItemHeader class --------------------

    static PyObject* _new_NavigationViewItemHeader(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::Microsoft::UI::Xaml::Controls::NavigationViewItemHeader 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_NavigationViewItemHeader(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemHeader* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_NavigationViewItemHeader(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemHeader>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewItemHeader(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemHeader>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewItemHeader[] = {
        { "_assign_array_", _assign_array_NavigationViewItemHeader, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewItemHeader), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewItemHeader[] = {
        { }
    };

    static PyType_Slot _type_slots_NavigationViewItemHeader[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewItemHeader) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewItemHeader) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewItemHeader) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewItemHeader) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewItemHeader =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItemHeader",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemHeader),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewItemHeader
    };

    // ----- NavigationViewItemInvokedEventArgs class --------------------

    static PyObject* _new_NavigationViewItemInvokedEventArgs(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::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs 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_NavigationViewItemInvokedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewItemInvokedEventArgs_get_InvokedItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs", L"InvokedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InvokedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItemInvokedEventArgs_get_IsSettingsInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs", L"IsSettingsInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSettingsInvoked());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItemInvokedEventArgs_get_InvokedItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs", L"InvokedItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InvokedItemContainer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewItemInvokedEventArgs_get_RecommendedNavigationTransitionInfo(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs", L"RecommendedNavigationTransitionInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RecommendedNavigationTransitionInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewItemInvokedEventArgs[] = {
        { "_assign_array_", _assign_array_NavigationViewItemInvokedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewItemInvokedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewItemInvokedEventArgs[] = {
        { "invoked_item", reinterpret_cast<getter>(NavigationViewItemInvokedEventArgs_get_InvokedItem), nullptr, nullptr, nullptr },
        { "is_settings_invoked", reinterpret_cast<getter>(NavigationViewItemInvokedEventArgs_get_IsSettingsInvoked), nullptr, nullptr, nullptr },
        { "invoked_item_container", reinterpret_cast<getter>(NavigationViewItemInvokedEventArgs_get_InvokedItemContainer), nullptr, nullptr, nullptr },
        { "recommended_navigation_transition_info", reinterpret_cast<getter>(NavigationViewItemInvokedEventArgs_get_RecommendedNavigationTransitionInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewItemInvokedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewItemInvokedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewItemInvokedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewItemInvokedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewItemInvokedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewItemInvokedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItemInvokedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewItemInvokedEventArgs
    };

    // ----- NavigationViewItemSeparator class --------------------

    static PyObject* _new_NavigationViewItemSeparator(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::Microsoft::UI::Xaml::Controls::NavigationViewItemSeparator 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_NavigationViewItemSeparator(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemSeparator* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_NavigationViewItemSeparator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemSeparator>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewItemSeparator(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewItemSeparator>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewItemSeparator[] = {
        { "_assign_array_", _assign_array_NavigationViewItemSeparator, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewItemSeparator), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewItemSeparator[] = {
        { }
    };

    static PyType_Slot _type_slots_NavigationViewItemSeparator[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewItemSeparator) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewItemSeparator) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewItemSeparator) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewItemSeparator) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewItemSeparator =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewItemSeparator",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewItemSeparator),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewItemSeparator
    };

    // ----- NavigationViewPaneClosingEventArgs class --------------------

    static PyObject* _new_NavigationViewPaneClosingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_NavigationViewPaneClosingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewPaneClosingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NavigationViewPaneClosingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_NavigationViewPaneClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewPaneClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewPaneClosingEventArgs[] = {
        { "_assign_array_", _assign_array_NavigationViewPaneClosingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewPaneClosingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewPaneClosingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(NavigationViewPaneClosingEventArgs_get_Cancel), reinterpret_cast<setter>(NavigationViewPaneClosingEventArgs_put_Cancel), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewPaneClosingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewPaneClosingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewPaneClosingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewPaneClosingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewPaneClosingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewPaneClosingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewPaneClosingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewPaneClosingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewPaneClosingEventArgs
    };

    // ----- NavigationViewSelectionChangedEventArgs class --------------------

    static PyObject* _new_NavigationViewSelectionChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_NavigationViewSelectionChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewSelectionChangedEventArgs_get_IsSettingsSelected(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs", L"IsSettingsSelected"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSettingsSelected());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewSelectionChangedEventArgs_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewSelectionChangedEventArgs_get_RecommendedNavigationTransitionInfo(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs", L"RecommendedNavigationTransitionInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RecommendedNavigationTransitionInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewSelectionChangedEventArgs_get_SelectedItemContainer(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs", L"SelectedItemContainer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItemContainer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewSelectionChangedEventArgs[] = {
        { "_assign_array_", _assign_array_NavigationViewSelectionChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewSelectionChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewSelectionChangedEventArgs[] = {
        { "is_settings_selected", reinterpret_cast<getter>(NavigationViewSelectionChangedEventArgs_get_IsSettingsSelected), nullptr, nullptr, nullptr },
        { "selected_item", reinterpret_cast<getter>(NavigationViewSelectionChangedEventArgs_get_SelectedItem), nullptr, nullptr, nullptr },
        { "recommended_navigation_transition_info", reinterpret_cast<getter>(NavigationViewSelectionChangedEventArgs_get_RecommendedNavigationTransitionInfo), nullptr, nullptr, nullptr },
        { "selected_item_container", reinterpret_cast<getter>(NavigationViewSelectionChangedEventArgs_get_SelectedItemContainer), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewSelectionChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewSelectionChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewSelectionChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewSelectionChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewSelectionChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewSelectionChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewSelectionChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewSelectionChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewSelectionChangedEventArgs
    };

    // ----- NavigationViewTemplateSettings class --------------------

    static PyObject* _new_NavigationViewTemplateSettings(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::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings 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_NavigationViewTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NavigationViewTemplateSettings_get_BackButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"BackButtonVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BackButtonVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_LeftPaneVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"LeftPaneVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LeftPaneVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_OverflowButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"OverflowButtonVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OverflowButtonVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_PaneToggleButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"PaneToggleButtonVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneToggleButtonVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_PaneToggleButtonWidth(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"PaneToggleButtonWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneToggleButtonWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_SingleSelectionFollowsFocus(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"SingleSelectionFollowsFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SingleSelectionFollowsFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_SmallerPaneToggleButtonWidth(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"SmallerPaneToggleButtonWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SmallerPaneToggleButtonWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_TopPadding(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"TopPadding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopPadding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_TopPaneVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"TopPaneVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopPaneVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_OpenPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"OpenPaneLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OpenPaneLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_BackButtonVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"BackButtonVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::BackButtonVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_LeftPaneVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"LeftPaneVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::LeftPaneVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_OverflowButtonVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"OverflowButtonVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::OverflowButtonVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_PaneToggleButtonVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"PaneToggleButtonVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::PaneToggleButtonVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_PaneToggleButtonWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"PaneToggleButtonWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::PaneToggleButtonWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_SingleSelectionFollowsFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"SingleSelectionFollowsFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::SingleSelectionFollowsFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_SmallerPaneToggleButtonWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"SmallerPaneToggleButtonWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::SmallerPaneToggleButtonWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_TopPaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"TopPaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::TopPaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_TopPaneVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"TopPaneVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::TopPaneVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NavigationViewTemplateSettings_get_OpenPaneLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings", L"OpenPaneLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings::OpenPaneLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NavigationViewTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NavigationViewTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NavigationViewTemplateSettings[] = {
        { "_assign_array_", _assign_array_NavigationViewTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NavigationViewTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NavigationViewTemplateSettings[] = {
        { "back_button_visibility", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_BackButtonVisibility), nullptr, nullptr, nullptr },
        { "left_pane_visibility", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_LeftPaneVisibility), nullptr, nullptr, nullptr },
        { "overflow_button_visibility", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_OverflowButtonVisibility), nullptr, nullptr, nullptr },
        { "pane_toggle_button_visibility", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_PaneToggleButtonVisibility), nullptr, nullptr, nullptr },
        { "pane_toggle_button_width", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_PaneToggleButtonWidth), nullptr, nullptr, nullptr },
        { "single_selection_follows_focus", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_SingleSelectionFollowsFocus), nullptr, nullptr, nullptr },
        { "smaller_pane_toggle_button_width", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_SmallerPaneToggleButtonWidth), nullptr, nullptr, nullptr },
        { "top_padding", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_TopPadding), nullptr, nullptr, nullptr },
        { "top_pane_visibility", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_TopPaneVisibility), nullptr, nullptr, nullptr },
        { "open_pane_length", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_OpenPaneLength), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NavigationViewTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NavigationViewTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NavigationViewTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NavigationViewTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NavigationViewTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_NavigationViewTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NavigationViewTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NavigationViewTemplateSettings
    };

    static PyGetSetDef getset_NavigationViewTemplateSettings_Static[] = {
        { "back_button_visibility_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_BackButtonVisibilityProperty), nullptr, nullptr, nullptr },
        { "left_pane_visibility_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_LeftPaneVisibilityProperty), nullptr, nullptr, nullptr },
        { "overflow_button_visibility_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_OverflowButtonVisibilityProperty), nullptr, nullptr, nullptr },
        { "pane_toggle_button_visibility_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_PaneToggleButtonVisibilityProperty), nullptr, nullptr, nullptr },
        { "pane_toggle_button_width_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_PaneToggleButtonWidthProperty), nullptr, nullptr, nullptr },
        { "single_selection_follows_focus_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_SingleSelectionFollowsFocusProperty), nullptr, nullptr, nullptr },
        { "smaller_pane_toggle_button_width_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_SmallerPaneToggleButtonWidthProperty), nullptr, nullptr, nullptr },
        { "top_padding_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_TopPaddingProperty), nullptr, nullptr, nullptr },
        { "top_pane_visibility_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_TopPaneVisibilityProperty), nullptr, nullptr, nullptr },
        { "open_pane_length_property", reinterpret_cast<getter>(NavigationViewTemplateSettings_get_OpenPaneLengthProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_NavigationViewTemplateSettings_Static[] = {
        { }
    };

    static PyType_Slot type_slots_NavigationViewTemplateSettings_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_NavigationViewTemplateSettings_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_NavigationViewTemplateSettings_Static) },
        { }
    };

    static PyType_Spec type_spec_NavigationViewTemplateSettings_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NavigationViewTemplateSettings_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_NavigationViewTemplateSettings_Static
    };

    // ----- NonVirtualizingLayout class --------------------

    static PyObject* _new_NonVirtualizingLayout(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::Microsoft::UI::Xaml::Controls::NonVirtualizingLayout 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_NonVirtualizingLayout(py::wrapper::Microsoft::UI::Xaml::Controls::NonVirtualizingLayout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_NonVirtualizingLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NonVirtualizingLayout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NonVirtualizingLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NonVirtualizingLayout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NonVirtualizingLayout[] = {
        { "_assign_array_", _assign_array_NonVirtualizingLayout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NonVirtualizingLayout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NonVirtualizingLayout[] = {
        { }
    };

    static PyType_Slot _type_slots_NonVirtualizingLayout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NonVirtualizingLayout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NonVirtualizingLayout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NonVirtualizingLayout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NonVirtualizingLayout) },
        { },
    };

    static PyType_Spec type_spec_NonVirtualizingLayout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NonVirtualizingLayout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NonVirtualizingLayout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NonVirtualizingLayout
    };

    // ----- NonVirtualizingLayoutContext class --------------------

    static PyObject* _new_NonVirtualizingLayoutContext(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::Microsoft::UI::Xaml::Controls::NonVirtualizingLayoutContext 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_NonVirtualizingLayoutContext(py::wrapper::Microsoft::UI::Xaml::Controls::NonVirtualizingLayoutContext* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NonVirtualizingLayoutContext_get_Children(py::wrapper::Microsoft::UI::Xaml::Controls::NonVirtualizingLayoutContext* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NonVirtualizingLayoutContext", L"Children"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Children());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NonVirtualizingLayoutContext(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NonVirtualizingLayoutContext>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NonVirtualizingLayoutContext(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NonVirtualizingLayoutContext>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NonVirtualizingLayoutContext[] = {
        { "_assign_array_", _assign_array_NonVirtualizingLayoutContext, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NonVirtualizingLayoutContext), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NonVirtualizingLayoutContext[] = {
        { "children", reinterpret_cast<getter>(NonVirtualizingLayoutContext_get_Children), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NonVirtualizingLayoutContext[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NonVirtualizingLayoutContext) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NonVirtualizingLayoutContext) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NonVirtualizingLayoutContext) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NonVirtualizingLayoutContext) },
        { },
    };

    static PyType_Spec type_spec_NonVirtualizingLayoutContext =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NonVirtualizingLayoutContext",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NonVirtualizingLayoutContext),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NonVirtualizingLayoutContext
    };

    // ----- NumberBox class --------------------

    static PyObject* _new_NumberBox(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::Microsoft::UI::Xaml::Controls::NumberBox 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_NumberBox(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NumberBox_get_Value(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", 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 NumberBox_put_Value(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", 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<double>(arg);

            self->obj.Value(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_ValidationMode(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"ValidationMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ValidationMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_ValidationMode(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"ValidationMode"))
        {
            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::Microsoft::UI::Xaml::Controls::NumberBoxValidationMode>(arg);

            self->obj.ValidationMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"TextReadingOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextReadingOrder());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"TextReadingOrder"))
        {
            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::Microsoft::UI::Xaml::TextReadingOrder>(arg);

            self->obj.TextReadingOrder(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_SpinButtonPlacementMode(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SpinButtonPlacementMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SpinButtonPlacementMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_SpinButtonPlacementMode(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SpinButtonPlacementMode"))
        {
            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::Microsoft::UI::Xaml::Controls::NumberBoxSpinButtonPlacementMode>(arg);

            self->obj.SpinButtonPlacementMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_SmallChange(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SmallChange"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SmallChange());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_SmallChange(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SmallChange"))
        {
            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<double>(arg);

            self->obj.SmallChange(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SelectionHighlightColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SelectionHighlightColor"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SelectionFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SelectionFlyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

            self->obj.SelectionFlyout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreventKeyboardDisplayOnProgrammaticFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            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.PreventKeyboardDisplayOnProgrammaticFocus(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"PlaceholderText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"PlaceholderText"))
        {
            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.PlaceholderText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_NumberFormatter(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"NumberFormatter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NumberFormatter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_NumberFormatter(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"NumberFormatter"))
        {
            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::Globalization::NumberFormatting::INumberFormatter2>(arg);

            self->obj.NumberFormatter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_Minimum(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Minimum"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Minimum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_Minimum(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Minimum"))
        {
            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<double>(arg);

            self->obj.Minimum(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_Maximum(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Maximum"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Maximum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_Maximum(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Maximum"))
        {
            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<double>(arg);

            self->obj.Maximum(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_LargeChange(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"LargeChange"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LargeChange());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_LargeChange(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"LargeChange"))
        {
            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<double>(arg);

            self->obj.LargeChange(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_IsWrapEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"IsWrapEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsWrapEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_IsWrapEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"IsWrapEnabled"))
        {
            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.IsWrapEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_Description(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Description"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Description());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_Description(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"Description"))
        {
            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.Description(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_AcceptsExpression(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"AcceptsExpression"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AcceptsExpression());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int NumberBox_put_AcceptsExpression(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"AcceptsExpression"))
        {
            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.AcceptsExpression(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* NumberBox_get_AcceptsExpressionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"AcceptsExpressionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::AcceptsExpressionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_DescriptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"DescriptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::DescriptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_IsWrapEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"IsWrapEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::IsWrapEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_LargeChangeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"LargeChangeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::LargeChangeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_MaximumProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"MaximumProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::MaximumProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_MinimumProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"MinimumProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::MinimumProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_NumberFormatterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"NumberFormatterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::NumberFormatterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_PlaceholderTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"PlaceholderTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::PlaceholderTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"PreventKeyboardDisplayOnProgrammaticFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::PreventKeyboardDisplayOnProgrammaticFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_SelectionFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SelectionFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::SelectionFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_SelectionHighlightColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SelectionHighlightColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::SelectionHighlightColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_SmallChangeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SmallChangeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::SmallChangeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_SpinButtonPlacementModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"SpinButtonPlacementModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::SpinButtonPlacementModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_TextReadingOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"TextReadingOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::TextReadingOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_ValidationModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"ValidationModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::ValidationModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_get_ValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"ValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::NumberBox::ValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_add_ValueChanged(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"ValueChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::NumberBox, winrt::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs>>(arg);

            return py::convert(self->obj.ValueChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBox_remove_ValueChanged(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.NumberBox", L"ValueChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ValueChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NumberBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NumberBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NumberBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NumberBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NumberBox[] = {
        { "add_value_changed", reinterpret_cast<PyCFunction>(NumberBox_add_ValueChanged), METH_O, nullptr },
        { "remove_value_changed", reinterpret_cast<PyCFunction>(NumberBox_remove_ValueChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_NumberBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NumberBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NumberBox[] = {
        { "value", reinterpret_cast<getter>(NumberBox_get_Value), reinterpret_cast<setter>(NumberBox_put_Value), nullptr, nullptr },
        { "validation_mode", reinterpret_cast<getter>(NumberBox_get_ValidationMode), reinterpret_cast<setter>(NumberBox_put_ValidationMode), nullptr, nullptr },
        { "text_reading_order", reinterpret_cast<getter>(NumberBox_get_TextReadingOrder), reinterpret_cast<setter>(NumberBox_put_TextReadingOrder), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(NumberBox_get_Text), reinterpret_cast<setter>(NumberBox_put_Text), nullptr, nullptr },
        { "spin_button_placement_mode", reinterpret_cast<getter>(NumberBox_get_SpinButtonPlacementMode), reinterpret_cast<setter>(NumberBox_put_SpinButtonPlacementMode), nullptr, nullptr },
        { "small_change", reinterpret_cast<getter>(NumberBox_get_SmallChange), reinterpret_cast<setter>(NumberBox_put_SmallChange), nullptr, nullptr },
        { "selection_highlight_color", reinterpret_cast<getter>(NumberBox_get_SelectionHighlightColor), reinterpret_cast<setter>(NumberBox_put_SelectionHighlightColor), nullptr, nullptr },
        { "selection_flyout", reinterpret_cast<getter>(NumberBox_get_SelectionFlyout), reinterpret_cast<setter>(NumberBox_put_SelectionFlyout), nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus", reinterpret_cast<getter>(NumberBox_get_PreventKeyboardDisplayOnProgrammaticFocus), reinterpret_cast<setter>(NumberBox_put_PreventKeyboardDisplayOnProgrammaticFocus), nullptr, nullptr },
        { "placeholder_text", reinterpret_cast<getter>(NumberBox_get_PlaceholderText), reinterpret_cast<setter>(NumberBox_put_PlaceholderText), nullptr, nullptr },
        { "number_formatter", reinterpret_cast<getter>(NumberBox_get_NumberFormatter), reinterpret_cast<setter>(NumberBox_put_NumberFormatter), nullptr, nullptr },
        { "minimum", reinterpret_cast<getter>(NumberBox_get_Minimum), reinterpret_cast<setter>(NumberBox_put_Minimum), nullptr, nullptr },
        { "maximum", reinterpret_cast<getter>(NumberBox_get_Maximum), reinterpret_cast<setter>(NumberBox_put_Maximum), nullptr, nullptr },
        { "large_change", reinterpret_cast<getter>(NumberBox_get_LargeChange), reinterpret_cast<setter>(NumberBox_put_LargeChange), nullptr, nullptr },
        { "is_wrap_enabled", reinterpret_cast<getter>(NumberBox_get_IsWrapEnabled), reinterpret_cast<setter>(NumberBox_put_IsWrapEnabled), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(NumberBox_get_HeaderTemplate), reinterpret_cast<setter>(NumberBox_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(NumberBox_get_Header), reinterpret_cast<setter>(NumberBox_put_Header), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(NumberBox_get_Description), reinterpret_cast<setter>(NumberBox_put_Description), nullptr, nullptr },
        { "accepts_expression", reinterpret_cast<getter>(NumberBox_get_AcceptsExpression), reinterpret_cast<setter>(NumberBox_put_AcceptsExpression), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NumberBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NumberBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NumberBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NumberBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NumberBox) },
        { },
    };

    static PyType_Spec type_spec_NumberBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NumberBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NumberBox
    };

    static PyGetSetDef getset_NumberBox_Static[] = {
        { "accepts_expression_property", reinterpret_cast<getter>(NumberBox_get_AcceptsExpressionProperty), nullptr, nullptr, nullptr },
        { "description_property", reinterpret_cast<getter>(NumberBox_get_DescriptionProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(NumberBox_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(NumberBox_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_wrap_enabled_property", reinterpret_cast<getter>(NumberBox_get_IsWrapEnabledProperty), nullptr, nullptr, nullptr },
        { "large_change_property", reinterpret_cast<getter>(NumberBox_get_LargeChangeProperty), nullptr, nullptr, nullptr },
        { "maximum_property", reinterpret_cast<getter>(NumberBox_get_MaximumProperty), nullptr, nullptr, nullptr },
        { "minimum_property", reinterpret_cast<getter>(NumberBox_get_MinimumProperty), nullptr, nullptr, nullptr },
        { "number_formatter_property", reinterpret_cast<getter>(NumberBox_get_NumberFormatterProperty), nullptr, nullptr, nullptr },
        { "placeholder_text_property", reinterpret_cast<getter>(NumberBox_get_PlaceholderTextProperty), nullptr, nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus_property", reinterpret_cast<getter>(NumberBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty), nullptr, nullptr, nullptr },
        { "selection_flyout_property", reinterpret_cast<getter>(NumberBox_get_SelectionFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_property", reinterpret_cast<getter>(NumberBox_get_SelectionHighlightColorProperty), nullptr, nullptr, nullptr },
        { "small_change_property", reinterpret_cast<getter>(NumberBox_get_SmallChangeProperty), nullptr, nullptr, nullptr },
        { "spin_button_placement_mode_property", reinterpret_cast<getter>(NumberBox_get_SpinButtonPlacementModeProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(NumberBox_get_TextProperty), nullptr, nullptr, nullptr },
        { "text_reading_order_property", reinterpret_cast<getter>(NumberBox_get_TextReadingOrderProperty), nullptr, nullptr, nullptr },
        { "validation_mode_property", reinterpret_cast<getter>(NumberBox_get_ValidationModeProperty), nullptr, nullptr, nullptr },
        { "value_property", reinterpret_cast<getter>(NumberBox_get_ValueProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_NumberBox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_NumberBox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_NumberBox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_NumberBox_Static) },
        { }
    };

    static PyType_Spec type_spec_NumberBox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NumberBox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_NumberBox_Static
    };

    // ----- NumberBoxValueChangedEventArgs class --------------------

    static PyObject* _new_NumberBoxValueChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_NumberBoxValueChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* NumberBoxValueChangedEventArgs_get_NewValue(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBoxValueChangedEventArgs", L"NewValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* NumberBoxValueChangedEventArgs_get_OldValue(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.NumberBoxValueChangedEventArgs", L"OldValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OldValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_NumberBoxValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_NumberBoxValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_NumberBoxValueChangedEventArgs[] = {
        { "_assign_array_", _assign_array_NumberBoxValueChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_NumberBoxValueChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_NumberBoxValueChangedEventArgs[] = {
        { "new_value", reinterpret_cast<getter>(NumberBoxValueChangedEventArgs_get_NewValue), nullptr, nullptr, nullptr },
        { "old_value", reinterpret_cast<getter>(NumberBoxValueChangedEventArgs_get_OldValue), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_NumberBoxValueChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_NumberBoxValueChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_NumberBoxValueChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_NumberBoxValueChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_NumberBoxValueChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_NumberBoxValueChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.NumberBoxValueChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::NumberBoxValueChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_NumberBoxValueChangedEventArgs
    };

    // ----- Page class --------------------

    static PyObject* _new_Page(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::Microsoft::UI::Xaml::Controls::Page 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_Page(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Page_get_TopAppBar(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"TopAppBar"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopAppBar());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Page_put_TopAppBar(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"TopAppBar"))
        {
            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::Microsoft::UI::Xaml::Controls::AppBar>(arg);

            self->obj.TopAppBar(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Page_get_NavigationCacheMode(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"NavigationCacheMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NavigationCacheMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Page_put_NavigationCacheMode(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"NavigationCacheMode"))
        {
            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::Microsoft::UI::Xaml::Navigation::NavigationCacheMode>(arg);

            self->obj.NavigationCacheMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Page_get_BottomAppBar(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"BottomAppBar"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BottomAppBar());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Page_put_BottomAppBar(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"BottomAppBar"))
        {
            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::Microsoft::UI::Xaml::Controls::AppBar>(arg);

            self->obj.BottomAppBar(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Page_get_Frame(py::wrapper::Microsoft::UI::Xaml::Controls::Page* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"Frame"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Frame());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Page_get_BottomAppBarProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"BottomAppBarProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Page::BottomAppBarProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Page_get_FrameProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"FrameProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Page::FrameProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Page_get_TopAppBarProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Page", L"TopAppBarProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Page::TopAppBarProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Page(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Page>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Page(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Page>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Page[] = {
        { "_assign_array_", _assign_array_Page, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Page), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Page[] = {
        { "top_app_bar", reinterpret_cast<getter>(Page_get_TopAppBar), reinterpret_cast<setter>(Page_put_TopAppBar), nullptr, nullptr },
        { "navigation_cache_mode", reinterpret_cast<getter>(Page_get_NavigationCacheMode), reinterpret_cast<setter>(Page_put_NavigationCacheMode), nullptr, nullptr },
        { "bottom_app_bar", reinterpret_cast<getter>(Page_get_BottomAppBar), reinterpret_cast<setter>(Page_put_BottomAppBar), nullptr, nullptr },
        { "frame", reinterpret_cast<getter>(Page_get_Frame), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Page[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Page) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Page) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Page) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Page) },
        { },
    };

    static PyType_Spec type_spec_Page =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Page",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Page),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Page
    };

    static PyGetSetDef getset_Page_Static[] = {
        { "bottom_app_bar_property", reinterpret_cast<getter>(Page_get_BottomAppBarProperty), nullptr, nullptr, nullptr },
        { "frame_property", reinterpret_cast<getter>(Page_get_FrameProperty), nullptr, nullptr, nullptr },
        { "top_app_bar_property", reinterpret_cast<getter>(Page_get_TopAppBarProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Page_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Page_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Page_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Page_Static) },
        { }
    };

    static PyType_Spec type_spec_Page_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Page_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Page_Static
    };

    // ----- Panel class --------------------

    static PyObject* _new_Panel(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::Panel>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::Panel>::type_name);
        return nullptr;
    }

    static void _dealloc_Panel(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Panel_get_ChildrenTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"ChildrenTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ChildrenTransitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Panel_put_ChildrenTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"ChildrenTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

            self->obj.ChildrenTransitions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Panel_get_BackgroundTransition(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"BackgroundTransition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BackgroundTransition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Panel_put_BackgroundTransition(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"BackgroundTransition"))
        {
            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::Microsoft::UI::Xaml::BrushTransition>(arg);

            self->obj.BackgroundTransition(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Panel_get_Background(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"Background"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Background());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Panel_put_Background(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"Background"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Background(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Panel_get_Children(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"Children"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Children());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Panel_get_IsItemsHost(py::wrapper::Microsoft::UI::Xaml::Controls::Panel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"IsItemsHost"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsItemsHost());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Panel_get_BackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"BackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Panel::BackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Panel_get_ChildrenTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"ChildrenTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Panel::ChildrenTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Panel_get_IsItemsHostProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Panel", L"IsItemsHostProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Panel::IsItemsHostProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Panel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Panel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Panel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Panel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Panel[] = {
        { "_assign_array_", _assign_array_Panel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Panel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Panel[] = {
        { "children_transitions", reinterpret_cast<getter>(Panel_get_ChildrenTransitions), reinterpret_cast<setter>(Panel_put_ChildrenTransitions), nullptr, nullptr },
        { "background_transition", reinterpret_cast<getter>(Panel_get_BackgroundTransition), reinterpret_cast<setter>(Panel_put_BackgroundTransition), nullptr, nullptr },
        { "background", reinterpret_cast<getter>(Panel_get_Background), reinterpret_cast<setter>(Panel_put_Background), nullptr, nullptr },
        { "children", reinterpret_cast<getter>(Panel_get_Children), nullptr, nullptr, nullptr },
        { "is_items_host", reinterpret_cast<getter>(Panel_get_IsItemsHost), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Panel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Panel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Panel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Panel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Panel) },
        { },
    };

    static PyType_Spec type_spec_Panel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Panel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Panel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Panel
    };

    static PyGetSetDef getset_Panel_Static[] = {
        { "background_property", reinterpret_cast<getter>(Panel_get_BackgroundProperty), nullptr, nullptr, nullptr },
        { "children_transitions_property", reinterpret_cast<getter>(Panel_get_ChildrenTransitionsProperty), nullptr, nullptr, nullptr },
        { "is_items_host_property", reinterpret_cast<getter>(Panel_get_IsItemsHostProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Panel_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Panel_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Panel_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Panel_Static) },
        { }
    };

    static PyType_Spec type_spec_Panel_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Panel_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Panel_Static
    };

    // ----- ParallaxView class --------------------

    static PyObject* _new_ParallaxView(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::Microsoft::UI::Xaml::Controls::ParallaxView 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_ParallaxView(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ParallaxView_RefreshAutomaticHorizontalOffsets(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"RefreshAutomaticHorizontalOffsets", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RefreshAutomaticHorizontalOffsets();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ParallaxView_RefreshAutomaticVerticalOffsets(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"RefreshAutomaticVerticalOffsets", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RefreshAutomaticVerticalOffsets();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_VerticalSourceStartOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceStartOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalSourceStartOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_VerticalSourceStartOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceStartOffset"))
        {
            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<double>(arg);

            self->obj.VerticalSourceStartOffset(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_VerticalSourceOffsetKind(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceOffsetKind"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalSourceOffsetKind());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_VerticalSourceOffsetKind(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceOffsetKind"))
        {
            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::Microsoft::UI::Xaml::Controls::ParallaxSourceOffsetKind>(arg);

            self->obj.VerticalSourceOffsetKind(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_VerticalSourceEndOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceEndOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalSourceEndOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_VerticalSourceEndOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceEndOffset"))
        {
            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<double>(arg);

            self->obj.VerticalSourceEndOffset(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_VerticalShift(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalShift"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalShift());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_VerticalShift(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalShift"))
        {
            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<double>(arg);

            self->obj.VerticalShift(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Source());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"Source"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Source(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_MaxVerticalShiftRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"MaxVerticalShiftRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxVerticalShiftRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_MaxVerticalShiftRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"MaxVerticalShiftRatio"))
        {
            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<double>(arg);

            self->obj.MaxVerticalShiftRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_MaxHorizontalShiftRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"MaxHorizontalShiftRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxHorizontalShiftRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_MaxHorizontalShiftRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"MaxHorizontalShiftRatio"))
        {
            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<double>(arg);

            self->obj.MaxHorizontalShiftRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_IsVerticalShiftClamped(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"IsVerticalShiftClamped"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsVerticalShiftClamped());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_IsVerticalShiftClamped(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"IsVerticalShiftClamped"))
        {
            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.IsVerticalShiftClamped(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_IsHorizontalShiftClamped(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"IsHorizontalShiftClamped"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsHorizontalShiftClamped());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_IsHorizontalShiftClamped(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"IsHorizontalShiftClamped"))
        {
            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.IsHorizontalShiftClamped(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_HorizontalSourceStartOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceStartOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalSourceStartOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_HorizontalSourceStartOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceStartOffset"))
        {
            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<double>(arg);

            self->obj.HorizontalSourceStartOffset(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_HorizontalSourceOffsetKind(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceOffsetKind"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalSourceOffsetKind());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_HorizontalSourceOffsetKind(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceOffsetKind"))
        {
            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::Microsoft::UI::Xaml::Controls::ParallaxSourceOffsetKind>(arg);

            self->obj.HorizontalSourceOffsetKind(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_HorizontalSourceEndOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceEndOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalSourceEndOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_HorizontalSourceEndOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceEndOffset"))
        {
            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<double>(arg);

            self->obj.HorizontalSourceEndOffset(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_HorizontalShift(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalShift"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalShift());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_HorizontalShift(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalShift"))
        {
            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<double>(arg);

            self->obj.HorizontalShift(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_Child(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"Child"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Child());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ParallaxView_put_Child(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"Child"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Child(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ParallaxView_get_ChildProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"ChildProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::ChildProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_HorizontalShiftProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalShiftProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::HorizontalShiftProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_HorizontalSourceEndOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceEndOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::HorizontalSourceEndOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_HorizontalSourceOffsetKindProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceOffsetKindProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::HorizontalSourceOffsetKindProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_HorizontalSourceStartOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"HorizontalSourceStartOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::HorizontalSourceStartOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_IsHorizontalShiftClampedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"IsHorizontalShiftClampedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::IsHorizontalShiftClampedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_IsVerticalShiftClampedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"IsVerticalShiftClampedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::IsVerticalShiftClampedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_MaxHorizontalShiftRatioProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"MaxHorizontalShiftRatioProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::MaxHorizontalShiftRatioProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_MaxVerticalShiftRatioProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"MaxVerticalShiftRatioProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::MaxVerticalShiftRatioProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_VerticalShiftProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalShiftProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::VerticalShiftProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_VerticalSourceEndOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceEndOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::VerticalSourceEndOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_VerticalSourceOffsetKindProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceOffsetKindProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::VerticalSourceOffsetKindProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ParallaxView_get_VerticalSourceStartOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ParallaxView", L"VerticalSourceStartOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ParallaxView::VerticalSourceStartOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ParallaxView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ParallaxView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ParallaxView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ParallaxView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ParallaxView[] = {
        { "refresh_automatic_horizontal_offsets", reinterpret_cast<PyCFunction>(ParallaxView_RefreshAutomaticHorizontalOffsets), METH_VARARGS, nullptr },
        { "refresh_automatic_vertical_offsets", reinterpret_cast<PyCFunction>(ParallaxView_RefreshAutomaticVerticalOffsets), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ParallaxView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ParallaxView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ParallaxView[] = {
        { "vertical_source_start_offset", reinterpret_cast<getter>(ParallaxView_get_VerticalSourceStartOffset), reinterpret_cast<setter>(ParallaxView_put_VerticalSourceStartOffset), nullptr, nullptr },
        { "vertical_source_offset_kind", reinterpret_cast<getter>(ParallaxView_get_VerticalSourceOffsetKind), reinterpret_cast<setter>(ParallaxView_put_VerticalSourceOffsetKind), nullptr, nullptr },
        { "vertical_source_end_offset", reinterpret_cast<getter>(ParallaxView_get_VerticalSourceEndOffset), reinterpret_cast<setter>(ParallaxView_put_VerticalSourceEndOffset), nullptr, nullptr },
        { "vertical_shift", reinterpret_cast<getter>(ParallaxView_get_VerticalShift), reinterpret_cast<setter>(ParallaxView_put_VerticalShift), nullptr, nullptr },
        { "source", reinterpret_cast<getter>(ParallaxView_get_Source), reinterpret_cast<setter>(ParallaxView_put_Source), nullptr, nullptr },
        { "max_vertical_shift_ratio", reinterpret_cast<getter>(ParallaxView_get_MaxVerticalShiftRatio), reinterpret_cast<setter>(ParallaxView_put_MaxVerticalShiftRatio), nullptr, nullptr },
        { "max_horizontal_shift_ratio", reinterpret_cast<getter>(ParallaxView_get_MaxHorizontalShiftRatio), reinterpret_cast<setter>(ParallaxView_put_MaxHorizontalShiftRatio), nullptr, nullptr },
        { "is_vertical_shift_clamped", reinterpret_cast<getter>(ParallaxView_get_IsVerticalShiftClamped), reinterpret_cast<setter>(ParallaxView_put_IsVerticalShiftClamped), nullptr, nullptr },
        { "is_horizontal_shift_clamped", reinterpret_cast<getter>(ParallaxView_get_IsHorizontalShiftClamped), reinterpret_cast<setter>(ParallaxView_put_IsHorizontalShiftClamped), nullptr, nullptr },
        { "horizontal_source_start_offset", reinterpret_cast<getter>(ParallaxView_get_HorizontalSourceStartOffset), reinterpret_cast<setter>(ParallaxView_put_HorizontalSourceStartOffset), nullptr, nullptr },
        { "horizontal_source_offset_kind", reinterpret_cast<getter>(ParallaxView_get_HorizontalSourceOffsetKind), reinterpret_cast<setter>(ParallaxView_put_HorizontalSourceOffsetKind), nullptr, nullptr },
        { "horizontal_source_end_offset", reinterpret_cast<getter>(ParallaxView_get_HorizontalSourceEndOffset), reinterpret_cast<setter>(ParallaxView_put_HorizontalSourceEndOffset), nullptr, nullptr },
        { "horizontal_shift", reinterpret_cast<getter>(ParallaxView_get_HorizontalShift), reinterpret_cast<setter>(ParallaxView_put_HorizontalShift), nullptr, nullptr },
        { "child", reinterpret_cast<getter>(ParallaxView_get_Child), reinterpret_cast<setter>(ParallaxView_put_Child), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ParallaxView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ParallaxView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ParallaxView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ParallaxView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ParallaxView) },
        { },
    };

    static PyType_Spec type_spec_ParallaxView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ParallaxView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ParallaxView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ParallaxView
    };

    static PyGetSetDef getset_ParallaxView_Static[] = {
        { "child_property", reinterpret_cast<getter>(ParallaxView_get_ChildProperty), nullptr, nullptr, nullptr },
        { "horizontal_shift_property", reinterpret_cast<getter>(ParallaxView_get_HorizontalShiftProperty), nullptr, nullptr, nullptr },
        { "horizontal_source_end_offset_property", reinterpret_cast<getter>(ParallaxView_get_HorizontalSourceEndOffsetProperty), nullptr, nullptr, nullptr },
        { "horizontal_source_offset_kind_property", reinterpret_cast<getter>(ParallaxView_get_HorizontalSourceOffsetKindProperty), nullptr, nullptr, nullptr },
        { "horizontal_source_start_offset_property", reinterpret_cast<getter>(ParallaxView_get_HorizontalSourceStartOffsetProperty), nullptr, nullptr, nullptr },
        { "is_horizontal_shift_clamped_property", reinterpret_cast<getter>(ParallaxView_get_IsHorizontalShiftClampedProperty), nullptr, nullptr, nullptr },
        { "is_vertical_shift_clamped_property", reinterpret_cast<getter>(ParallaxView_get_IsVerticalShiftClampedProperty), nullptr, nullptr, nullptr },
        { "max_horizontal_shift_ratio_property", reinterpret_cast<getter>(ParallaxView_get_MaxHorizontalShiftRatioProperty), nullptr, nullptr, nullptr },
        { "max_vertical_shift_ratio_property", reinterpret_cast<getter>(ParallaxView_get_MaxVerticalShiftRatioProperty), nullptr, nullptr, nullptr },
        { "source_property", reinterpret_cast<getter>(ParallaxView_get_SourceProperty), nullptr, nullptr, nullptr },
        { "vertical_shift_property", reinterpret_cast<getter>(ParallaxView_get_VerticalShiftProperty), nullptr, nullptr, nullptr },
        { "vertical_source_end_offset_property", reinterpret_cast<getter>(ParallaxView_get_VerticalSourceEndOffsetProperty), nullptr, nullptr, nullptr },
        { "vertical_source_offset_kind_property", reinterpret_cast<getter>(ParallaxView_get_VerticalSourceOffsetKindProperty), nullptr, nullptr, nullptr },
        { "vertical_source_start_offset_property", reinterpret_cast<getter>(ParallaxView_get_VerticalSourceStartOffsetProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ParallaxView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ParallaxView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ParallaxView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ParallaxView_Static) },
        { }
    };

    static PyType_Spec type_spec_ParallaxView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ParallaxView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ParallaxView_Static
    };

    // ----- PasswordBox class --------------------

    static PyObject* _new_PasswordBox(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::Microsoft::UI::Xaml::Controls::PasswordBox 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_PasswordBox(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PasswordBox_PasteFromClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasteFromClipboard", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.PasteFromClipboard();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PasswordBox_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"TextReadingOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextReadingOrder());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"TextReadingOrder"))
        {
            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::Microsoft::UI::Xaml::TextReadingOrder>(arg);

            self->obj.TextReadingOrder(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"SelectionHighlightColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"SelectionHighlightColor"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"SelectionFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"SelectionFlyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

            self->obj.SelectionFlyout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreventKeyboardDisplayOnProgrammaticFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            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.PreventKeyboardDisplayOnProgrammaticFocus(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PlaceholderText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PlaceholderText"))
        {
            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.PlaceholderText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_PasswordRevealMode(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordRevealMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PasswordRevealMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_PasswordRevealMode(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordRevealMode"))
        {
            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::Microsoft::UI::Xaml::Controls::PasswordRevealMode>(arg);

            self->obj.PasswordRevealMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_PasswordChar(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordChar"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PasswordChar());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_PasswordChar(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordChar"))
        {
            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.PasswordChar(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_Password(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Password"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Password());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_Password(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Password"))
        {
            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.Password(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_MaxLength(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"MaxLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_MaxLength(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"MaxLength"))
        {
            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<int32_t>(arg);

            self->obj.MaxLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_IsPasswordRevealButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"IsPasswordRevealButtonEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPasswordRevealButtonEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_IsPasswordRevealButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"IsPasswordRevealButtonEnabled"))
        {
            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.IsPasswordRevealButtonEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_InputScope(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"InputScope"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InputScope());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_InputScope(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"InputScope"))
        {
            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::Microsoft::UI::Xaml::Input::InputScope>(arg);

            self->obj.InputScope(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_Description(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Description"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Description());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PasswordBox_put_Description(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Description"))
        {
            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.Description(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PasswordBox_get_CanPasteClipboardContent(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"CanPasteClipboardContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanPasteClipboardContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_CanPasteClipboardContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"CanPasteClipboardContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::CanPasteClipboardContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_DescriptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"DescriptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::DescriptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_InputScopeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"InputScopeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::InputScopeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_IsPasswordRevealButtonEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"IsPasswordRevealButtonEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::IsPasswordRevealButtonEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_MaxLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"MaxLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::MaxLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_PasswordCharProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordCharProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::PasswordCharProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_PasswordProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::PasswordProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_PasswordRevealModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordRevealModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::PasswordRevealModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_PlaceholderTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PlaceholderTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::PlaceholderTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PreventKeyboardDisplayOnProgrammaticFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::PreventKeyboardDisplayOnProgrammaticFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_SelectionFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"SelectionFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::SelectionFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_SelectionHighlightColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"SelectionHighlightColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::SelectionHighlightColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_get_TextReadingOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"TextReadingOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PasswordBox::TextReadingOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_add_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ContextMenuOpeningEventHandler>(arg);

            return py::convert(self->obj.ContextMenuOpening(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_remove_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ContextMenuOpening(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_add_PasswordChanged(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.PasswordChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_remove_PasswordChanged(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PasswordChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_add_PasswordChanging(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::PasswordBox, winrt::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs>>(arg);

            return py::convert(self->obj.PasswordChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_remove_PasswordChanging(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"PasswordChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PasswordChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_add_Paste(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Paste"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::TextControlPasteEventHandler>(arg);

            return py::convert(self->obj.Paste(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PasswordBox_remove_Paste(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PasswordBox", L"Paste"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Paste(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PasswordBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PasswordBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PasswordBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PasswordBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PasswordBox[] = {
        { "paste_from_clipboard", reinterpret_cast<PyCFunction>(PasswordBox_PasteFromClipboard), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(PasswordBox_SelectAll), METH_VARARGS, nullptr },
        { "add_context_menu_opening", reinterpret_cast<PyCFunction>(PasswordBox_add_ContextMenuOpening), METH_O, nullptr },
        { "remove_context_menu_opening", reinterpret_cast<PyCFunction>(PasswordBox_remove_ContextMenuOpening), METH_O, nullptr },
        { "add_password_changed", reinterpret_cast<PyCFunction>(PasswordBox_add_PasswordChanged), METH_O, nullptr },
        { "remove_password_changed", reinterpret_cast<PyCFunction>(PasswordBox_remove_PasswordChanged), METH_O, nullptr },
        { "add_password_changing", reinterpret_cast<PyCFunction>(PasswordBox_add_PasswordChanging), METH_O, nullptr },
        { "remove_password_changing", reinterpret_cast<PyCFunction>(PasswordBox_remove_PasswordChanging), METH_O, nullptr },
        { "add_paste", reinterpret_cast<PyCFunction>(PasswordBox_add_Paste), METH_O, nullptr },
        { "remove_paste", reinterpret_cast<PyCFunction>(PasswordBox_remove_Paste), METH_O, nullptr },
        { "_assign_array_", _assign_array_PasswordBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PasswordBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PasswordBox[] = {
        { "text_reading_order", reinterpret_cast<getter>(PasswordBox_get_TextReadingOrder), reinterpret_cast<setter>(PasswordBox_put_TextReadingOrder), nullptr, nullptr },
        { "selection_highlight_color", reinterpret_cast<getter>(PasswordBox_get_SelectionHighlightColor), reinterpret_cast<setter>(PasswordBox_put_SelectionHighlightColor), nullptr, nullptr },
        { "selection_flyout", reinterpret_cast<getter>(PasswordBox_get_SelectionFlyout), reinterpret_cast<setter>(PasswordBox_put_SelectionFlyout), nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus", reinterpret_cast<getter>(PasswordBox_get_PreventKeyboardDisplayOnProgrammaticFocus), reinterpret_cast<setter>(PasswordBox_put_PreventKeyboardDisplayOnProgrammaticFocus), nullptr, nullptr },
        { "placeholder_text", reinterpret_cast<getter>(PasswordBox_get_PlaceholderText), reinterpret_cast<setter>(PasswordBox_put_PlaceholderText), nullptr, nullptr },
        { "password_reveal_mode", reinterpret_cast<getter>(PasswordBox_get_PasswordRevealMode), reinterpret_cast<setter>(PasswordBox_put_PasswordRevealMode), nullptr, nullptr },
        { "password_char", reinterpret_cast<getter>(PasswordBox_get_PasswordChar), reinterpret_cast<setter>(PasswordBox_put_PasswordChar), nullptr, nullptr },
        { "password", reinterpret_cast<getter>(PasswordBox_get_Password), reinterpret_cast<setter>(PasswordBox_put_Password), nullptr, nullptr },
        { "max_length", reinterpret_cast<getter>(PasswordBox_get_MaxLength), reinterpret_cast<setter>(PasswordBox_put_MaxLength), nullptr, nullptr },
        { "is_password_reveal_button_enabled", reinterpret_cast<getter>(PasswordBox_get_IsPasswordRevealButtonEnabled), reinterpret_cast<setter>(PasswordBox_put_IsPasswordRevealButtonEnabled), nullptr, nullptr },
        { "input_scope", reinterpret_cast<getter>(PasswordBox_get_InputScope), reinterpret_cast<setter>(PasswordBox_put_InputScope), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(PasswordBox_get_HeaderTemplate), reinterpret_cast<setter>(PasswordBox_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(PasswordBox_get_Header), reinterpret_cast<setter>(PasswordBox_put_Header), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(PasswordBox_get_Description), reinterpret_cast<setter>(PasswordBox_put_Description), nullptr, nullptr },
        { "can_paste_clipboard_content", reinterpret_cast<getter>(PasswordBox_get_CanPasteClipboardContent), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PasswordBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PasswordBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PasswordBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PasswordBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PasswordBox) },
        { },
    };

    static PyType_Spec type_spec_PasswordBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PasswordBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PasswordBox
    };

    static PyGetSetDef getset_PasswordBox_Static[] = {
        { "can_paste_clipboard_content_property", reinterpret_cast<getter>(PasswordBox_get_CanPasteClipboardContentProperty), nullptr, nullptr, nullptr },
        { "description_property", reinterpret_cast<getter>(PasswordBox_get_DescriptionProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(PasswordBox_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(PasswordBox_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "input_scope_property", reinterpret_cast<getter>(PasswordBox_get_InputScopeProperty), nullptr, nullptr, nullptr },
        { "is_password_reveal_button_enabled_property", reinterpret_cast<getter>(PasswordBox_get_IsPasswordRevealButtonEnabledProperty), nullptr, nullptr, nullptr },
        { "max_length_property", reinterpret_cast<getter>(PasswordBox_get_MaxLengthProperty), nullptr, nullptr, nullptr },
        { "password_char_property", reinterpret_cast<getter>(PasswordBox_get_PasswordCharProperty), nullptr, nullptr, nullptr },
        { "password_property", reinterpret_cast<getter>(PasswordBox_get_PasswordProperty), nullptr, nullptr, nullptr },
        { "password_reveal_mode_property", reinterpret_cast<getter>(PasswordBox_get_PasswordRevealModeProperty), nullptr, nullptr, nullptr },
        { "placeholder_text_property", reinterpret_cast<getter>(PasswordBox_get_PlaceholderTextProperty), nullptr, nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus_property", reinterpret_cast<getter>(PasswordBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty), nullptr, nullptr, nullptr },
        { "selection_flyout_property", reinterpret_cast<getter>(PasswordBox_get_SelectionFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_property", reinterpret_cast<getter>(PasswordBox_get_SelectionHighlightColorProperty), nullptr, nullptr, nullptr },
        { "text_reading_order_property", reinterpret_cast<getter>(PasswordBox_get_TextReadingOrderProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_PasswordBox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_PasswordBox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PasswordBox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PasswordBox_Static) },
        { }
    };

    static PyType_Spec type_spec_PasswordBox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PasswordBox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PasswordBox_Static
    };

    // ----- PasswordBoxPasswordChangingEventArgs class --------------------

    static PyObject* _new_PasswordBoxPasswordChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_PasswordBoxPasswordChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PasswordBoxPasswordChangingEventArgs_get_IsContentChanging(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs", L"IsContentChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsContentChanging());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PasswordBoxPasswordChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PasswordBoxPasswordChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PasswordBoxPasswordChangingEventArgs[] = {
        { "_assign_array_", _assign_array_PasswordBoxPasswordChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PasswordBoxPasswordChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PasswordBoxPasswordChangingEventArgs[] = {
        { "is_content_changing", reinterpret_cast<getter>(PasswordBoxPasswordChangingEventArgs_get_IsContentChanging), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PasswordBoxPasswordChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PasswordBoxPasswordChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PasswordBoxPasswordChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PasswordBoxPasswordChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PasswordBoxPasswordChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PasswordBoxPasswordChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PasswordBoxPasswordChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PasswordBoxPasswordChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PasswordBoxPasswordChangingEventArgs
    };

    // ----- PathIcon class --------------------

    static PyObject* _new_PathIcon(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::Microsoft::UI::Xaml::Controls::PathIcon 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_PathIcon(py::wrapper::Microsoft::UI::Xaml::Controls::PathIcon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PathIcon_get_Data(py::wrapper::Microsoft::UI::Xaml::Controls::PathIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PathIcon", 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 PathIcon_put_Data(py::wrapper::Microsoft::UI::Xaml::Controls::PathIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PathIcon", 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::Microsoft::UI::Xaml::Media::Geometry>(arg);

            self->obj.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PathIcon_get_DataProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PathIcon", L"DataProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PathIcon::DataProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PathIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PathIcon>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PathIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PathIcon>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PathIcon[] = {
        { "_assign_array_", _assign_array_PathIcon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PathIcon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PathIcon[] = {
        { "data", reinterpret_cast<getter>(PathIcon_get_Data), reinterpret_cast<setter>(PathIcon_put_Data), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PathIcon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PathIcon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PathIcon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PathIcon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PathIcon) },
        { },
    };

    static PyType_Spec type_spec_PathIcon =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PathIcon",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PathIcon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PathIcon
    };

    static PyGetSetDef getset_PathIcon_Static[] = {
        { "data_property", reinterpret_cast<getter>(PathIcon_get_DataProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_PathIcon_Static[] = {
        { }
    };

    static PyType_Slot type_slots_PathIcon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PathIcon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PathIcon_Static) },
        { }
    };

    static PyType_Spec type_spec_PathIcon_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PathIcon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PathIcon_Static
    };

    // ----- PathIconSource class --------------------

    static PyObject* _new_PathIconSource(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::Microsoft::UI::Xaml::Controls::PathIconSource 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_PathIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::PathIconSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PathIconSource_get_Data(py::wrapper::Microsoft::UI::Xaml::Controls::PathIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PathIconSource", 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 PathIconSource_put_Data(py::wrapper::Microsoft::UI::Xaml::Controls::PathIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PathIconSource", 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::Microsoft::UI::Xaml::Media::Geometry>(arg);

            self->obj.Data(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PathIconSource_get_DataProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PathIconSource", L"DataProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PathIconSource::DataProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PathIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PathIconSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PathIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PathIconSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PathIconSource[] = {
        { "_assign_array_", _assign_array_PathIconSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PathIconSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PathIconSource[] = {
        { "data", reinterpret_cast<getter>(PathIconSource_get_Data), reinterpret_cast<setter>(PathIconSource_put_Data), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PathIconSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PathIconSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PathIconSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PathIconSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PathIconSource) },
        { },
    };

    static PyType_Spec type_spec_PathIconSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PathIconSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PathIconSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PathIconSource
    };

    static PyGetSetDef getset_PathIconSource_Static[] = {
        { "data_property", reinterpret_cast<getter>(PathIconSource_get_DataProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_PathIconSource_Static[] = {
        { }
    };

    static PyType_Slot type_slots_PathIconSource_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PathIconSource_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PathIconSource_Static) },
        { }
    };

    static PyType_Spec type_spec_PathIconSource_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PathIconSource_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PathIconSource_Static
    };

    // ----- PersonPicture class --------------------

    static PyObject* _new_PersonPicture(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::Microsoft::UI::Xaml::Controls::PersonPicture 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_PersonPicture(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PersonPicture_get_ProfilePicture(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"ProfilePicture"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ProfilePicture());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_ProfilePicture(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"ProfilePicture"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.ProfilePicture(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_PreferSmallImage(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"PreferSmallImage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreferSmallImage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_PreferSmallImage(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"PreferSmallImage"))
        {
            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.PreferSmallImage(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_IsGroup(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"IsGroup"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsGroup());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_IsGroup(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"IsGroup"))
        {
            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.IsGroup(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_Initials(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"Initials"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Initials());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_Initials(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"Initials"))
        {
            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.Initials(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_DisplayName(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"DisplayName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_DisplayName(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"DisplayName"))
        {
            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.DisplayName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_Contact(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"Contact"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Contact());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_Contact(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"Contact"))
        {
            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::ApplicationModel::Contacts::Contact>(arg);

            self->obj.Contact(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_BadgeText(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BadgeText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_BadgeText(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeText"))
        {
            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.BadgeText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_BadgeNumber(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeNumber"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BadgeNumber());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_BadgeNumber(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeNumber"))
        {
            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<int32_t>(arg);

            self->obj.BadgeNumber(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_BadgeImageSource(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeImageSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BadgeImageSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_BadgeImageSource(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeImageSource"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.BadgeImageSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_BadgeGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BadgeGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PersonPicture_put_BadgeGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeGlyph"))
        {
            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.BadgeGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PersonPicture_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_BadgeGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::BadgeGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_BadgeImageSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeImageSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::BadgeImageSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_BadgeNumberProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeNumberProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::BadgeNumberProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_BadgeTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"BadgeTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::BadgeTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_ContactProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"ContactProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::ContactProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_DisplayNameProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"DisplayNameProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::DisplayNameProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_InitialsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"InitialsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::InitialsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_IsGroupProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"IsGroupProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::IsGroupProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_PreferSmallImageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"PreferSmallImageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::PreferSmallImageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPicture_get_ProfilePictureProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPicture", L"ProfilePictureProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PersonPicture::ProfilePictureProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PersonPicture(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PersonPicture>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PersonPicture(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PersonPicture>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PersonPicture[] = {
        { "_assign_array_", _assign_array_PersonPicture, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PersonPicture), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PersonPicture[] = {
        { "profile_picture", reinterpret_cast<getter>(PersonPicture_get_ProfilePicture), reinterpret_cast<setter>(PersonPicture_put_ProfilePicture), nullptr, nullptr },
        { "prefer_small_image", reinterpret_cast<getter>(PersonPicture_get_PreferSmallImage), reinterpret_cast<setter>(PersonPicture_put_PreferSmallImage), nullptr, nullptr },
        { "is_group", reinterpret_cast<getter>(PersonPicture_get_IsGroup), reinterpret_cast<setter>(PersonPicture_put_IsGroup), nullptr, nullptr },
        { "initials", reinterpret_cast<getter>(PersonPicture_get_Initials), reinterpret_cast<setter>(PersonPicture_put_Initials), nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(PersonPicture_get_DisplayName), reinterpret_cast<setter>(PersonPicture_put_DisplayName), nullptr, nullptr },
        { "contact", reinterpret_cast<getter>(PersonPicture_get_Contact), reinterpret_cast<setter>(PersonPicture_put_Contact), nullptr, nullptr },
        { "badge_text", reinterpret_cast<getter>(PersonPicture_get_BadgeText), reinterpret_cast<setter>(PersonPicture_put_BadgeText), nullptr, nullptr },
        { "badge_number", reinterpret_cast<getter>(PersonPicture_get_BadgeNumber), reinterpret_cast<setter>(PersonPicture_put_BadgeNumber), nullptr, nullptr },
        { "badge_image_source", reinterpret_cast<getter>(PersonPicture_get_BadgeImageSource), reinterpret_cast<setter>(PersonPicture_put_BadgeImageSource), nullptr, nullptr },
        { "badge_glyph", reinterpret_cast<getter>(PersonPicture_get_BadgeGlyph), reinterpret_cast<setter>(PersonPicture_put_BadgeGlyph), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(PersonPicture_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PersonPicture[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PersonPicture) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PersonPicture) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PersonPicture) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PersonPicture) },
        { },
    };

    static PyType_Spec type_spec_PersonPicture =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PersonPicture",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPicture),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PersonPicture
    };

    static PyGetSetDef getset_PersonPicture_Static[] = {
        { "badge_glyph_property", reinterpret_cast<getter>(PersonPicture_get_BadgeGlyphProperty), nullptr, nullptr, nullptr },
        { "badge_image_source_property", reinterpret_cast<getter>(PersonPicture_get_BadgeImageSourceProperty), nullptr, nullptr, nullptr },
        { "badge_number_property", reinterpret_cast<getter>(PersonPicture_get_BadgeNumberProperty), nullptr, nullptr, nullptr },
        { "badge_text_property", reinterpret_cast<getter>(PersonPicture_get_BadgeTextProperty), nullptr, nullptr, nullptr },
        { "contact_property", reinterpret_cast<getter>(PersonPicture_get_ContactProperty), nullptr, nullptr, nullptr },
        { "display_name_property", reinterpret_cast<getter>(PersonPicture_get_DisplayNameProperty), nullptr, nullptr, nullptr },
        { "initials_property", reinterpret_cast<getter>(PersonPicture_get_InitialsProperty), nullptr, nullptr, nullptr },
        { "is_group_property", reinterpret_cast<getter>(PersonPicture_get_IsGroupProperty), nullptr, nullptr, nullptr },
        { "prefer_small_image_property", reinterpret_cast<getter>(PersonPicture_get_PreferSmallImageProperty), nullptr, nullptr, nullptr },
        { "profile_picture_property", reinterpret_cast<getter>(PersonPicture_get_ProfilePictureProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_PersonPicture_Static[] = {
        { }
    };

    static PyType_Slot type_slots_PersonPicture_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PersonPicture_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PersonPicture_Static) },
        { }
    };

    static PyType_Spec type_spec_PersonPicture_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PersonPicture_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PersonPicture_Static
    };

    // ----- PersonPictureTemplateSettings class --------------------

    static PyObject* _new_PersonPictureTemplateSettings(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings>::type_name);
        return nullptr;
    }

    static void _dealloc_PersonPictureTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PersonPictureTemplateSettings_get_ActualImageBrush(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPictureTemplateSettings", L"ActualImageBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActualImageBrush());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PersonPictureTemplateSettings_get_ActualInitials(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PersonPictureTemplateSettings", L"ActualInitials"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActualInitials());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PersonPictureTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PersonPictureTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PersonPictureTemplateSettings[] = {
        { "_assign_array_", _assign_array_PersonPictureTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PersonPictureTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PersonPictureTemplateSettings[] = {
        { "actual_image_brush", reinterpret_cast<getter>(PersonPictureTemplateSettings_get_ActualImageBrush), nullptr, nullptr, nullptr },
        { "actual_initials", reinterpret_cast<getter>(PersonPictureTemplateSettings_get_ActualInitials), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PersonPictureTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PersonPictureTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PersonPictureTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PersonPictureTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PersonPictureTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_PersonPictureTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PersonPictureTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PersonPictureTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PersonPictureTemplateSettings
    };

    // ----- PickerConfirmedEventArgs class --------------------

    static PyObject* _new_PickerConfirmedEventArgs(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::Microsoft::UI::Xaml::Controls::PickerConfirmedEventArgs 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_PickerConfirmedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::PickerConfirmedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_PickerConfirmedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PickerConfirmedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PickerConfirmedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PickerConfirmedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PickerConfirmedEventArgs[] = {
        { "_assign_array_", _assign_array_PickerConfirmedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PickerConfirmedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PickerConfirmedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_PickerConfirmedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PickerConfirmedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PickerConfirmedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PickerConfirmedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PickerConfirmedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PickerConfirmedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PickerConfirmedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PickerConfirmedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PickerConfirmedEventArgs
    };

    // ----- PickerFlyout class --------------------

    static PyObject* _new_PickerFlyout(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::Microsoft::UI::Xaml::Controls::PickerFlyout 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_PickerFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PickerFlyout_ShowAtAsync(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"ShowAtAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(self->obj.ShowAtAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PickerFlyout_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PickerFlyout_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"Content"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PickerFlyout_get_ConfirmationButtonsVisible(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"ConfirmationButtonsVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ConfirmationButtonsVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PickerFlyout_put_ConfirmationButtonsVisible(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"ConfirmationButtonsVisible"))
        {
            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.ConfirmationButtonsVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PickerFlyout_get_ConfirmationButtonsVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"ConfirmationButtonsVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PickerFlyout::ConfirmationButtonsVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PickerFlyout_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PickerFlyout::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PickerFlyout_add_Confirmed(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"Confirmed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::PickerFlyout, winrt::Microsoft::UI::Xaml::Controls::PickerConfirmedEventArgs>>(arg);

            return py::convert(self->obj.Confirmed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PickerFlyout_remove_Confirmed(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PickerFlyout", L"Confirmed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Confirmed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PickerFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PickerFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PickerFlyout[] = {
        { "show_at_async", reinterpret_cast<PyCFunction>(PickerFlyout_ShowAtAsync), METH_VARARGS, nullptr },
        { "add_confirmed", reinterpret_cast<PyCFunction>(PickerFlyout_add_Confirmed), METH_O, nullptr },
        { "remove_confirmed", reinterpret_cast<PyCFunction>(PickerFlyout_remove_Confirmed), METH_O, nullptr },
        { "_assign_array_", _assign_array_PickerFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PickerFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PickerFlyout[] = {
        { "content", reinterpret_cast<getter>(PickerFlyout_get_Content), reinterpret_cast<setter>(PickerFlyout_put_Content), nullptr, nullptr },
        { "confirmation_buttons_visible", reinterpret_cast<getter>(PickerFlyout_get_ConfirmationButtonsVisible), reinterpret_cast<setter>(PickerFlyout_put_ConfirmationButtonsVisible), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PickerFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PickerFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PickerFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PickerFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PickerFlyout) },
        { },
    };

    static PyType_Spec type_spec_PickerFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PickerFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PickerFlyout
    };

    static PyGetSetDef getset_PickerFlyout_Static[] = {
        { "confirmation_buttons_visible_property", reinterpret_cast<getter>(PickerFlyout_get_ConfirmationButtonsVisibleProperty), nullptr, nullptr, nullptr },
        { "content_property", reinterpret_cast<getter>(PickerFlyout_get_ContentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_PickerFlyout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_PickerFlyout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PickerFlyout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PickerFlyout_Static) },
        { }
    };

    static PyType_Spec type_spec_PickerFlyout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PickerFlyout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PickerFlyout_Static
    };

    // ----- PickerFlyoutPresenter class --------------------

    static PyObject* _new_PickerFlyoutPresenter(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PickerFlyoutPresenter>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PickerFlyoutPresenter>::type_name);
        return nullptr;
    }

    static void _dealloc_PickerFlyoutPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyoutPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_PickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PickerFlyoutPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PickerFlyoutPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PickerFlyoutPresenter[] = {
        { "_assign_array_", _assign_array_PickerFlyoutPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PickerFlyoutPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PickerFlyoutPresenter[] = {
        { }
    };

    static PyType_Slot _type_slots_PickerFlyoutPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PickerFlyoutPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PickerFlyoutPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PickerFlyoutPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PickerFlyoutPresenter) },
        { },
    };

    static PyType_Spec type_spec_PickerFlyoutPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PickerFlyoutPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PickerFlyoutPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PickerFlyoutPresenter
    };

    // ----- PipsPager class --------------------

    static PyObject* _new_PipsPager(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::Microsoft::UI::Xaml::Controls::PipsPager 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_PipsPager(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PipsPager_get_SelectedPipStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedPipStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedPipStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_SelectedPipStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedPipStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.SelectedPipStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_SelectedPageIndex(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedPageIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedPageIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_SelectedPageIndex(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedPageIndex"))
        {
            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<int32_t>(arg);

            self->obj.SelectedPageIndex(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_PreviousButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"PreviousButtonVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreviousButtonVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_PreviousButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"PreviousButtonVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::PipsPagerButtonVisibility>(arg);

            self->obj.PreviousButtonVisibility(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_PreviousButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"PreviousButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreviousButtonStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_PreviousButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"PreviousButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.PreviousButtonStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_NumberOfPages(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NumberOfPages"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NumberOfPages());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_NumberOfPages(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NumberOfPages"))
        {
            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<int32_t>(arg);

            self->obj.NumberOfPages(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_NormalPipStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NormalPipStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NormalPipStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_NormalPipStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NormalPipStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.NormalPipStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_NextButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NextButtonVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NextButtonVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_NextButtonVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NextButtonVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::PipsPagerButtonVisibility>(arg);

            self->obj.NextButtonVisibility(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_NextButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NextButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NextButtonStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_NextButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NextButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.NextButtonStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_MaxVisiblePips(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"MaxVisiblePips"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxVisiblePips());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PipsPager_put_MaxVisiblePips(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"MaxVisiblePips"))
        {
            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<int32_t>(arg);

            self->obj.MaxVisiblePips(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PipsPager_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_MaxVisiblePipsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"MaxVisiblePipsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::MaxVisiblePipsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_NextButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NextButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::NextButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_NextButtonVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NextButtonVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::NextButtonVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_NormalPipStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NormalPipStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::NormalPipStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_NumberOfPagesProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"NumberOfPagesProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::NumberOfPagesProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_PreviousButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"PreviousButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::PreviousButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_PreviousButtonVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"PreviousButtonVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::PreviousButtonVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_SelectedPageIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedPageIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::SelectedPageIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_get_SelectedPipStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedPipStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PipsPager::SelectedPipStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_add_SelectedIndexChanged(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedIndexChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::PipsPager, winrt::Microsoft::UI::Xaml::Controls::PipsPagerSelectedIndexChangedEventArgs>>(arg);

            return py::convert(self->obj.SelectedIndexChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PipsPager_remove_SelectedIndexChanged(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.PipsPager", L"SelectedIndexChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectedIndexChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PipsPager(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PipsPager>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PipsPager(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PipsPager>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PipsPager[] = {
        { "add_selected_index_changed", reinterpret_cast<PyCFunction>(PipsPager_add_SelectedIndexChanged), METH_O, nullptr },
        { "remove_selected_index_changed", reinterpret_cast<PyCFunction>(PipsPager_remove_SelectedIndexChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_PipsPager, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PipsPager), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PipsPager[] = {
        { "selected_pip_style", reinterpret_cast<getter>(PipsPager_get_SelectedPipStyle), reinterpret_cast<setter>(PipsPager_put_SelectedPipStyle), nullptr, nullptr },
        { "selected_page_index", reinterpret_cast<getter>(PipsPager_get_SelectedPageIndex), reinterpret_cast<setter>(PipsPager_put_SelectedPageIndex), nullptr, nullptr },
        { "previous_button_visibility", reinterpret_cast<getter>(PipsPager_get_PreviousButtonVisibility), reinterpret_cast<setter>(PipsPager_put_PreviousButtonVisibility), nullptr, nullptr },
        { "previous_button_style", reinterpret_cast<getter>(PipsPager_get_PreviousButtonStyle), reinterpret_cast<setter>(PipsPager_put_PreviousButtonStyle), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(PipsPager_get_Orientation), reinterpret_cast<setter>(PipsPager_put_Orientation), nullptr, nullptr },
        { "number_of_pages", reinterpret_cast<getter>(PipsPager_get_NumberOfPages), reinterpret_cast<setter>(PipsPager_put_NumberOfPages), nullptr, nullptr },
        { "normal_pip_style", reinterpret_cast<getter>(PipsPager_get_NormalPipStyle), reinterpret_cast<setter>(PipsPager_put_NormalPipStyle), nullptr, nullptr },
        { "next_button_visibility", reinterpret_cast<getter>(PipsPager_get_NextButtonVisibility), reinterpret_cast<setter>(PipsPager_put_NextButtonVisibility), nullptr, nullptr },
        { "next_button_style", reinterpret_cast<getter>(PipsPager_get_NextButtonStyle), reinterpret_cast<setter>(PipsPager_put_NextButtonStyle), nullptr, nullptr },
        { "max_visible_pips", reinterpret_cast<getter>(PipsPager_get_MaxVisiblePips), reinterpret_cast<setter>(PipsPager_put_MaxVisiblePips), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(PipsPager_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PipsPager[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PipsPager) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PipsPager) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PipsPager) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PipsPager) },
        { },
    };

    static PyType_Spec type_spec_PipsPager =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PipsPager",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPager),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PipsPager
    };

    static PyGetSetDef getset_PipsPager_Static[] = {
        { "max_visible_pips_property", reinterpret_cast<getter>(PipsPager_get_MaxVisiblePipsProperty), nullptr, nullptr, nullptr },
        { "next_button_style_property", reinterpret_cast<getter>(PipsPager_get_NextButtonStyleProperty), nullptr, nullptr, nullptr },
        { "next_button_visibility_property", reinterpret_cast<getter>(PipsPager_get_NextButtonVisibilityProperty), nullptr, nullptr, nullptr },
        { "normal_pip_style_property", reinterpret_cast<getter>(PipsPager_get_NormalPipStyleProperty), nullptr, nullptr, nullptr },
        { "number_of_pages_property", reinterpret_cast<getter>(PipsPager_get_NumberOfPagesProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(PipsPager_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "previous_button_style_property", reinterpret_cast<getter>(PipsPager_get_PreviousButtonStyleProperty), nullptr, nullptr, nullptr },
        { "previous_button_visibility_property", reinterpret_cast<getter>(PipsPager_get_PreviousButtonVisibilityProperty), nullptr, nullptr, nullptr },
        { "selected_page_index_property", reinterpret_cast<getter>(PipsPager_get_SelectedPageIndexProperty), nullptr, nullptr, nullptr },
        { "selected_pip_style_property", reinterpret_cast<getter>(PipsPager_get_SelectedPipStyleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_PipsPager_Static[] = {
        { }
    };

    static PyType_Slot type_slots_PipsPager_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PipsPager_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PipsPager_Static) },
        { }
    };

    static PyType_Spec type_spec_PipsPager_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PipsPager_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PipsPager_Static
    };

    // ----- PipsPagerSelectedIndexChangedEventArgs class --------------------

    static PyObject* _new_PipsPagerSelectedIndexChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PipsPagerSelectedIndexChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PipsPagerSelectedIndexChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_PipsPagerSelectedIndexChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPagerSelectedIndexChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_PipsPagerSelectedIndexChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PipsPagerSelectedIndexChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PipsPagerSelectedIndexChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PipsPagerSelectedIndexChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PipsPagerSelectedIndexChangedEventArgs[] = {
        { "_assign_array_", _assign_array_PipsPagerSelectedIndexChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PipsPagerSelectedIndexChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PipsPagerSelectedIndexChangedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_PipsPagerSelectedIndexChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PipsPagerSelectedIndexChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PipsPagerSelectedIndexChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PipsPagerSelectedIndexChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PipsPagerSelectedIndexChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PipsPagerSelectedIndexChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PipsPagerSelectedIndexChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPagerSelectedIndexChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PipsPagerSelectedIndexChangedEventArgs
    };

    // ----- PipsPagerTemplateSettings class --------------------

    static PyObject* _new_PipsPagerTemplateSettings(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PipsPagerTemplateSettings>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::PipsPagerTemplateSettings>::type_name);
        return nullptr;
    }

    static void _dealloc_PipsPagerTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPagerTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PipsPagerTemplateSettings_get_PipsPagerItems(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPagerTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PipsPagerTemplateSettings", L"PipsPagerItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PipsPagerItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PipsPagerTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PipsPagerTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PipsPagerTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PipsPagerTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PipsPagerTemplateSettings[] = {
        { "_assign_array_", _assign_array_PipsPagerTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PipsPagerTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PipsPagerTemplateSettings[] = {
        { "pips_pager_items", reinterpret_cast<getter>(PipsPagerTemplateSettings_get_PipsPagerItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PipsPagerTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PipsPagerTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PipsPagerTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PipsPagerTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PipsPagerTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_PipsPagerTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PipsPagerTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PipsPagerTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PipsPagerTemplateSettings
    };

    // ----- Pivot class --------------------

    static PyObject* _new_Pivot(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::Microsoft::UI::Xaml::Controls::Pivot 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_Pivot(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Pivot_GetSlideInAnimationGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"GetSlideInAnimationGroup", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::GetSlideInAnimationGroup(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Pivot_SetSlideInAnimationGroup(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SetSlideInAnimationGroup", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::PivotSlideInAnimationGroup>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::Pivot::SetSlideInAnimationGroup(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Pivot_get_TitleTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"TitleTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TitleTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_TitleTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"TitleTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.TitleTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_Title(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"Title"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Title());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_Title(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"Title"))
        {
            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.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectedItem"))
        {
            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.SelectedItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectedIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectedIndex"))
        {
            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<int32_t>(arg);

            self->obj.SelectedIndex(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_RightHeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"RightHeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RightHeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_RightHeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"RightHeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.RightHeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_RightHeader(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"RightHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RightHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_RightHeader(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"RightHeader"))
        {
            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.RightHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_LeftHeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"LeftHeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LeftHeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_LeftHeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"LeftHeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.LeftHeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_LeftHeader(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"LeftHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LeftHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_LeftHeader(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"LeftHeader"))
        {
            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.LeftHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_IsLocked(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"IsLocked"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsLocked());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_IsLocked(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"IsLocked"))
        {
            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.IsLocked(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_IsHeaderItemsCarouselEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"IsHeaderItemsCarouselEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsHeaderItemsCarouselEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_IsHeaderItemsCarouselEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"IsHeaderItemsCarouselEnabled"))
        {
            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.IsHeaderItemsCarouselEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_HeaderFocusVisualPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"HeaderFocusVisualPlacement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderFocusVisualPlacement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Pivot_put_HeaderFocusVisualPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"HeaderFocusVisualPlacement"))
        {
            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::Microsoft::UI::Xaml::Controls::PivotHeaderFocusVisualPlacement>(arg);

            self->obj.HeaderFocusVisualPlacement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Pivot_get_HeaderFocusVisualPlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"HeaderFocusVisualPlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::HeaderFocusVisualPlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_IsHeaderItemsCarouselEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"IsHeaderItemsCarouselEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::IsHeaderItemsCarouselEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_IsLockedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"IsLockedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::IsLockedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_LeftHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"LeftHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::LeftHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_LeftHeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"LeftHeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::LeftHeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_RightHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"RightHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::RightHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_RightHeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"RightHeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::RightHeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_SelectedIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectedIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::SelectedIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_SlideInAnimationGroupProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SlideInAnimationGroupProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::SlideInAnimationGroupProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_TitleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"TitleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::TitleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_get_TitleTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"TitleTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Pivot::TitleTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_add_PivotItemLoaded(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemLoaded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Pivot, winrt::Microsoft::UI::Xaml::Controls::PivotItemEventArgs>>(arg);

            return py::convert(self->obj.PivotItemLoaded(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_remove_PivotItemLoaded(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemLoaded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PivotItemLoaded(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_add_PivotItemLoading(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemLoading"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Pivot, winrt::Microsoft::UI::Xaml::Controls::PivotItemEventArgs>>(arg);

            return py::convert(self->obj.PivotItemLoading(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_remove_PivotItemLoading(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemLoading"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PivotItemLoading(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_add_PivotItemUnloaded(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemUnloaded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Pivot, winrt::Microsoft::UI::Xaml::Controls::PivotItemEventArgs>>(arg);

            return py::convert(self->obj.PivotItemUnloaded(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_remove_PivotItemUnloaded(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemUnloaded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PivotItemUnloaded(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_add_PivotItemUnloading(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemUnloading"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::Pivot, winrt::Microsoft::UI::Xaml::Controls::PivotItemEventArgs>>(arg);

            return py::convert(self->obj.PivotItemUnloading(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_remove_PivotItemUnloading(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"PivotItemUnloading"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PivotItemUnloading(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SelectionChangedEventHandler>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Pivot_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.Pivot", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Pivot(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Pivot>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Pivot(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Pivot>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Pivot[] = {
        { "add_pivot_item_loaded", reinterpret_cast<PyCFunction>(Pivot_add_PivotItemLoaded), METH_O, nullptr },
        { "remove_pivot_item_loaded", reinterpret_cast<PyCFunction>(Pivot_remove_PivotItemLoaded), METH_O, nullptr },
        { "add_pivot_item_loading", reinterpret_cast<PyCFunction>(Pivot_add_PivotItemLoading), METH_O, nullptr },
        { "remove_pivot_item_loading", reinterpret_cast<PyCFunction>(Pivot_remove_PivotItemLoading), METH_O, nullptr },
        { "add_pivot_item_unloaded", reinterpret_cast<PyCFunction>(Pivot_add_PivotItemUnloaded), METH_O, nullptr },
        { "remove_pivot_item_unloaded", reinterpret_cast<PyCFunction>(Pivot_remove_PivotItemUnloaded), METH_O, nullptr },
        { "add_pivot_item_unloading", reinterpret_cast<PyCFunction>(Pivot_add_PivotItemUnloading), METH_O, nullptr },
        { "remove_pivot_item_unloading", reinterpret_cast<PyCFunction>(Pivot_remove_PivotItemUnloading), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(Pivot_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(Pivot_remove_SelectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_Pivot, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Pivot), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Pivot[] = {
        { "title_template", reinterpret_cast<getter>(Pivot_get_TitleTemplate), reinterpret_cast<setter>(Pivot_put_TitleTemplate), nullptr, nullptr },
        { "title", reinterpret_cast<getter>(Pivot_get_Title), reinterpret_cast<setter>(Pivot_put_Title), nullptr, nullptr },
        { "selected_item", reinterpret_cast<getter>(Pivot_get_SelectedItem), reinterpret_cast<setter>(Pivot_put_SelectedItem), nullptr, nullptr },
        { "selected_index", reinterpret_cast<getter>(Pivot_get_SelectedIndex), reinterpret_cast<setter>(Pivot_put_SelectedIndex), nullptr, nullptr },
        { "right_header_template", reinterpret_cast<getter>(Pivot_get_RightHeaderTemplate), reinterpret_cast<setter>(Pivot_put_RightHeaderTemplate), nullptr, nullptr },
        { "right_header", reinterpret_cast<getter>(Pivot_get_RightHeader), reinterpret_cast<setter>(Pivot_put_RightHeader), nullptr, nullptr },
        { "left_header_template", reinterpret_cast<getter>(Pivot_get_LeftHeaderTemplate), reinterpret_cast<setter>(Pivot_put_LeftHeaderTemplate), nullptr, nullptr },
        { "left_header", reinterpret_cast<getter>(Pivot_get_LeftHeader), reinterpret_cast<setter>(Pivot_put_LeftHeader), nullptr, nullptr },
        { "is_locked", reinterpret_cast<getter>(Pivot_get_IsLocked), reinterpret_cast<setter>(Pivot_put_IsLocked), nullptr, nullptr },
        { "is_header_items_carousel_enabled", reinterpret_cast<getter>(Pivot_get_IsHeaderItemsCarouselEnabled), reinterpret_cast<setter>(Pivot_put_IsHeaderItemsCarouselEnabled), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(Pivot_get_HeaderTemplate), reinterpret_cast<setter>(Pivot_put_HeaderTemplate), nullptr, nullptr },
        { "header_focus_visual_placement", reinterpret_cast<getter>(Pivot_get_HeaderFocusVisualPlacement), reinterpret_cast<setter>(Pivot_put_HeaderFocusVisualPlacement), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Pivot[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Pivot) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Pivot) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Pivot) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Pivot) },
        { },
    };

    static PyType_Spec type_spec_Pivot =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Pivot",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Pivot),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Pivot
    };

    static PyGetSetDef getset_Pivot_Static[] = {
        { "header_focus_visual_placement_property", reinterpret_cast<getter>(Pivot_get_HeaderFocusVisualPlacementProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(Pivot_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_header_items_carousel_enabled_property", reinterpret_cast<getter>(Pivot_get_IsHeaderItemsCarouselEnabledProperty), nullptr, nullptr, nullptr },
        { "is_locked_property", reinterpret_cast<getter>(Pivot_get_IsLockedProperty), nullptr, nullptr, nullptr },
        { "left_header_property", reinterpret_cast<getter>(Pivot_get_LeftHeaderProperty), nullptr, nullptr, nullptr },
        { "left_header_template_property", reinterpret_cast<getter>(Pivot_get_LeftHeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "right_header_property", reinterpret_cast<getter>(Pivot_get_RightHeaderProperty), nullptr, nullptr, nullptr },
        { "right_header_template_property", reinterpret_cast<getter>(Pivot_get_RightHeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "selected_index_property", reinterpret_cast<getter>(Pivot_get_SelectedIndexProperty), nullptr, nullptr, nullptr },
        { "selected_item_property", reinterpret_cast<getter>(Pivot_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { "slide_in_animation_group_property", reinterpret_cast<getter>(Pivot_get_SlideInAnimationGroupProperty), nullptr, nullptr, nullptr },
        { "title_property", reinterpret_cast<getter>(Pivot_get_TitleProperty), nullptr, nullptr, nullptr },
        { "title_template_property", reinterpret_cast<getter>(Pivot_get_TitleTemplateProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Pivot_Static[] = {
        { "get_slide_in_animation_group", reinterpret_cast<PyCFunction>(Pivot_GetSlideInAnimationGroup), METH_VARARGS, nullptr },
        { "set_slide_in_animation_group", reinterpret_cast<PyCFunction>(Pivot_SetSlideInAnimationGroup), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_Pivot_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Pivot_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Pivot_Static) },
        { }
    };

    static PyType_Spec type_spec_Pivot_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Pivot_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Pivot_Static
    };

    // ----- PivotItem class --------------------

    static PyObject* _new_PivotItem(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::Microsoft::UI::Xaml::Controls::PivotItem 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_PivotItem(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PivotItem_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PivotItem", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PivotItem_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PivotItem", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* PivotItem_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PivotItem", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::PivotItem::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_PivotItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PivotItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PivotItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PivotItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PivotItem[] = {
        { "_assign_array_", _assign_array_PivotItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PivotItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PivotItem[] = {
        { "header", reinterpret_cast<getter>(PivotItem_get_Header), reinterpret_cast<setter>(PivotItem_put_Header), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PivotItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PivotItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PivotItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PivotItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PivotItem) },
        { },
    };

    static PyType_Spec type_spec_PivotItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PivotItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PivotItem
    };

    static PyGetSetDef getset_PivotItem_Static[] = {
        { "header_property", reinterpret_cast<getter>(PivotItem_get_HeaderProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_PivotItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_PivotItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_PivotItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_PivotItem_Static) },
        { }
    };

    static PyType_Spec type_spec_PivotItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PivotItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_PivotItem_Static
    };

    // ----- PivotItemEventArgs class --------------------

    static PyObject* _new_PivotItemEventArgs(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::Microsoft::UI::Xaml::Controls::PivotItemEventArgs 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_PivotItemEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItemEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PivotItemEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItemEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PivotItemEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int PivotItemEventArgs_put_Item(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItemEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.PivotItemEventArgs", L"Item"))
        {
            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::Microsoft::UI::Xaml::Controls::PivotItem>(arg);

            self->obj.Item(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_PivotItemEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::PivotItemEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PivotItemEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::PivotItemEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PivotItemEventArgs[] = {
        { "_assign_array_", _assign_array_PivotItemEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PivotItemEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PivotItemEventArgs[] = {
        { "item", reinterpret_cast<getter>(PivotItemEventArgs_get_Item), reinterpret_cast<setter>(PivotItemEventArgs_put_Item), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PivotItemEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PivotItemEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PivotItemEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PivotItemEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PivotItemEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PivotItemEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.PivotItemEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::PivotItemEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PivotItemEventArgs
    };

    // ----- ProgressBar class --------------------

    static PyObject* _new_ProgressBar(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::Microsoft::UI::Xaml::Controls::ProgressBar 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_ProgressBar(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ProgressBar_get_ShowPaused(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"ShowPaused"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ShowPaused());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ProgressBar_put_ShowPaused(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"ShowPaused"))
        {
            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.ShowPaused(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressBar_get_ShowError(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"ShowError"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ShowError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ProgressBar_put_ShowError(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"ShowError"))
        {
            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.ShowError(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressBar_get_IsIndeterminate(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"IsIndeterminate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsIndeterminate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ProgressBar_put_IsIndeterminate(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"IsIndeterminate"))
        {
            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.IsIndeterminate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressBar_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBar_get_IsIndeterminateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"IsIndeterminateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressBar::IsIndeterminateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBar_get_ShowErrorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"ShowErrorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressBar::ShowErrorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBar_get_ShowPausedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBar", L"ShowPausedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressBar::ShowPausedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ProgressBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ProgressBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ProgressBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ProgressBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ProgressBar[] = {
        { "_assign_array_", _assign_array_ProgressBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ProgressBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ProgressBar[] = {
        { "show_paused", reinterpret_cast<getter>(ProgressBar_get_ShowPaused), reinterpret_cast<setter>(ProgressBar_put_ShowPaused), nullptr, nullptr },
        { "show_error", reinterpret_cast<getter>(ProgressBar_get_ShowError), reinterpret_cast<setter>(ProgressBar_put_ShowError), nullptr, nullptr },
        { "is_indeterminate", reinterpret_cast<getter>(ProgressBar_get_IsIndeterminate), reinterpret_cast<setter>(ProgressBar_put_IsIndeterminate), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(ProgressBar_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ProgressBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ProgressBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ProgressBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ProgressBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ProgressBar) },
        { },
    };

    static PyType_Spec type_spec_ProgressBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ProgressBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ProgressBar
    };

    static PyGetSetDef getset_ProgressBar_Static[] = {
        { "is_indeterminate_property", reinterpret_cast<getter>(ProgressBar_get_IsIndeterminateProperty), nullptr, nullptr, nullptr },
        { "show_error_property", reinterpret_cast<getter>(ProgressBar_get_ShowErrorProperty), nullptr, nullptr, nullptr },
        { "show_paused_property", reinterpret_cast<getter>(ProgressBar_get_ShowPausedProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ProgressBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ProgressBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ProgressBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ProgressBar_Static) },
        { }
    };

    static PyType_Spec type_spec_ProgressBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ProgressBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ProgressBar_Static
    };

    // ----- ProgressBarTemplateSettings class --------------------

    static PyObject* _new_ProgressBarTemplateSettings(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings>::type_name);
        return nullptr;
    }

    static void _dealloc_ProgressBarTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ProgressBarTemplateSettings_get_ClipRect(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"ClipRect"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ClipRect());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_Container2AnimationEndPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"Container2AnimationEndPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Container2AnimationEndPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_Container2AnimationStartPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"Container2AnimationStartPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Container2AnimationStartPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_ContainerAnimationEndPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"ContainerAnimationEndPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContainerAnimationEndPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_ContainerAnimationMidPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"ContainerAnimationMidPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContainerAnimationMidPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_ContainerAnimationStartPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"ContainerAnimationStartPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContainerAnimationStartPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_EllipseAnimationEndPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"EllipseAnimationEndPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EllipseAnimationEndPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_EllipseAnimationWellPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"EllipseAnimationWellPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EllipseAnimationWellPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_EllipseDiameter(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"EllipseDiameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EllipseDiameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_EllipseOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"EllipseOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EllipseOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressBarTemplateSettings_get_IndicatorLengthDelta(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings", L"IndicatorLengthDelta"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IndicatorLengthDelta());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ProgressBarTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ProgressBarTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ProgressBarTemplateSettings[] = {
        { "_assign_array_", _assign_array_ProgressBarTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ProgressBarTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ProgressBarTemplateSettings[] = {
        { "clip_rect", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_ClipRect), nullptr, nullptr, nullptr },
        { "container2_animation_end_position", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_Container2AnimationEndPosition), nullptr, nullptr, nullptr },
        { "container2_animation_start_position", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_Container2AnimationStartPosition), nullptr, nullptr, nullptr },
        { "container_animation_end_position", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_ContainerAnimationEndPosition), nullptr, nullptr, nullptr },
        { "container_animation_mid_position", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_ContainerAnimationMidPosition), nullptr, nullptr, nullptr },
        { "container_animation_start_position", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_ContainerAnimationStartPosition), nullptr, nullptr, nullptr },
        { "ellipse_animation_end_position", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_EllipseAnimationEndPosition), nullptr, nullptr, nullptr },
        { "ellipse_animation_well_position", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_EllipseAnimationWellPosition), nullptr, nullptr, nullptr },
        { "ellipse_diameter", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_EllipseDiameter), nullptr, nullptr, nullptr },
        { "ellipse_offset", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_EllipseOffset), nullptr, nullptr, nullptr },
        { "indicator_length_delta", reinterpret_cast<getter>(ProgressBarTemplateSettings_get_IndicatorLengthDelta), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ProgressBarTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ProgressBarTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ProgressBarTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ProgressBarTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ProgressBarTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_ProgressBarTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ProgressBarTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressBarTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ProgressBarTemplateSettings
    };

    // ----- ProgressRing class --------------------

    static PyObject* _new_ProgressRing(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::Microsoft::UI::Xaml::Controls::ProgressRing 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_ProgressRing(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ProgressRing_get_Value(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", 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 ProgressRing_put_Value(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", 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<double>(arg);

            self->obj.Value(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressRing_get_Minimum(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"Minimum"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Minimum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ProgressRing_put_Minimum(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"Minimum"))
        {
            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<double>(arg);

            self->obj.Minimum(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressRing_get_Maximum(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"Maximum"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Maximum());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ProgressRing_put_Maximum(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"Maximum"))
        {
            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<double>(arg);

            self->obj.Maximum(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressRing_get_IsIndeterminate(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"IsIndeterminate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsIndeterminate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ProgressRing_put_IsIndeterminate(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"IsIndeterminate"))
        {
            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.IsIndeterminate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressRing_get_IsActive(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"IsActive"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsActive());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ProgressRing_put_IsActive(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"IsActive"))
        {
            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.IsActive(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ProgressRing_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressRing_get_IsActiveProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"IsActiveProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressRing::IsActiveProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressRing_get_IsIndeterminateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"IsIndeterminateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressRing::IsIndeterminateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressRing_get_MaximumProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"MaximumProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressRing::MaximumProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressRing_get_MinimumProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"MinimumProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressRing::MinimumProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressRing_get_ValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRing", L"ValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ProgressRing::ValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ProgressRing(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ProgressRing>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ProgressRing(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ProgressRing>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ProgressRing[] = {
        { "_assign_array_", _assign_array_ProgressRing, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ProgressRing), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ProgressRing[] = {
        { "value", reinterpret_cast<getter>(ProgressRing_get_Value), reinterpret_cast<setter>(ProgressRing_put_Value), nullptr, nullptr },
        { "minimum", reinterpret_cast<getter>(ProgressRing_get_Minimum), reinterpret_cast<setter>(ProgressRing_put_Minimum), nullptr, nullptr },
        { "maximum", reinterpret_cast<getter>(ProgressRing_get_Maximum), reinterpret_cast<setter>(ProgressRing_put_Maximum), nullptr, nullptr },
        { "is_indeterminate", reinterpret_cast<getter>(ProgressRing_get_IsIndeterminate), reinterpret_cast<setter>(ProgressRing_put_IsIndeterminate), nullptr, nullptr },
        { "is_active", reinterpret_cast<getter>(ProgressRing_get_IsActive), reinterpret_cast<setter>(ProgressRing_put_IsActive), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(ProgressRing_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ProgressRing[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ProgressRing) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ProgressRing) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ProgressRing) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ProgressRing) },
        { },
    };

    static PyType_Spec type_spec_ProgressRing =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ProgressRing",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRing),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ProgressRing
    };

    static PyGetSetDef getset_ProgressRing_Static[] = {
        { "is_active_property", reinterpret_cast<getter>(ProgressRing_get_IsActiveProperty), nullptr, nullptr, nullptr },
        { "is_indeterminate_property", reinterpret_cast<getter>(ProgressRing_get_IsIndeterminateProperty), nullptr, nullptr, nullptr },
        { "maximum_property", reinterpret_cast<getter>(ProgressRing_get_MaximumProperty), nullptr, nullptr, nullptr },
        { "minimum_property", reinterpret_cast<getter>(ProgressRing_get_MinimumProperty), nullptr, nullptr, nullptr },
        { "value_property", reinterpret_cast<getter>(ProgressRing_get_ValueProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ProgressRing_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ProgressRing_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ProgressRing_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ProgressRing_Static) },
        { }
    };

    static PyType_Spec type_spec_ProgressRing_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ProgressRing_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ProgressRing_Static
    };

    // ----- ProgressRingTemplateSettings class --------------------

    static PyObject* _new_ProgressRingTemplateSettings(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings>::type_name);
        return nullptr;
    }

    static void _dealloc_ProgressRingTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ProgressRingTemplateSettings_get_EllipseDiameter(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRingTemplateSettings", L"EllipseDiameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EllipseDiameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressRingTemplateSettings_get_EllipseOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRingTemplateSettings", L"EllipseOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EllipseOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProgressRingTemplateSettings_get_MaxSideLength(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ProgressRingTemplateSettings", L"MaxSideLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxSideLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ProgressRingTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ProgressRingTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ProgressRingTemplateSettings[] = {
        { "_assign_array_", _assign_array_ProgressRingTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ProgressRingTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ProgressRingTemplateSettings[] = {
        { "ellipse_diameter", reinterpret_cast<getter>(ProgressRingTemplateSettings_get_EllipseDiameter), nullptr, nullptr, nullptr },
        { "ellipse_offset", reinterpret_cast<getter>(ProgressRingTemplateSettings_get_EllipseOffset), nullptr, nullptr, nullptr },
        { "max_side_length", reinterpret_cast<getter>(ProgressRingTemplateSettings_get_MaxSideLength), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ProgressRingTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ProgressRingTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ProgressRingTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ProgressRingTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ProgressRingTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_ProgressRingTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ProgressRingTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ProgressRingTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ProgressRingTemplateSettings
    };

    // ----- RadioButton class --------------------

    static PyObject* _new_RadioButton(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::Microsoft::UI::Xaml::Controls::RadioButton 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_RadioButton(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButton* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RadioButton_get_GroupName(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButton", L"GroupName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButton_put_GroupName(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButton", L"GroupName"))
        {
            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.GroupName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButton_get_GroupNameProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButton", L"GroupNameProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButton::GroupNameProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RadioButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RadioButton>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RadioButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RadioButton>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RadioButton[] = {
        { "_assign_array_", _assign_array_RadioButton, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RadioButton), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RadioButton[] = {
        { "group_name", reinterpret_cast<getter>(RadioButton_get_GroupName), reinterpret_cast<setter>(RadioButton_put_GroupName), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RadioButton[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RadioButton) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RadioButton) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RadioButton) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RadioButton) },
        { },
    };

    static PyType_Spec type_spec_RadioButton =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RadioButton",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButton),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RadioButton
    };

    static PyGetSetDef getset_RadioButton_Static[] = {
        { "group_name_property", reinterpret_cast<getter>(RadioButton_get_GroupNameProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RadioButton_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RadioButton_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RadioButton_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RadioButton_Static) },
        { }
    };

    static PyType_Spec type_spec_RadioButton_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RadioButton_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RadioButton_Static
    };

    // ----- RadioButtons class --------------------

    static PyObject* _new_RadioButtons(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::Microsoft::UI::Xaml::Controls::RadioButtons 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_RadioButtons(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RadioButtons_ContainerFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ContainerFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.ContainerFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButtons_put_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectedItem"))
        {
            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.SelectedItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButtons_get_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectedIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButtons_put_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectedIndex"))
        {
            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<int32_t>(arg);

            self->obj.SelectedIndex(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButtons_get_MaxColumns(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"MaxColumns"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxColumns());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButtons_put_MaxColumns(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"MaxColumns"))
        {
            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<int32_t>(arg);

            self->obj.MaxColumns(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButtons_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButtons_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButtons_get_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButtons_put_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ItemTemplate"))
        {
            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.ItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButtons_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButtons_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButtons_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioButtons_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioButtons_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_ItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::ItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_ItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::ItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_MaxColumnsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"MaxColumnsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::MaxColumnsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_SelectedIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectedIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::SelectedIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioButtons::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SelectionChangedEventHandler>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioButtons_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RadioButtons", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RadioButtons(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RadioButtons>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RadioButtons(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RadioButtons>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RadioButtons[] = {
        { "container_from_index", reinterpret_cast<PyCFunction>(RadioButtons_ContainerFromIndex), METH_VARARGS, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(RadioButtons_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(RadioButtons_remove_SelectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_RadioButtons, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RadioButtons), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RadioButtons[] = {
        { "selected_item", reinterpret_cast<getter>(RadioButtons_get_SelectedItem), reinterpret_cast<setter>(RadioButtons_put_SelectedItem), nullptr, nullptr },
        { "selected_index", reinterpret_cast<getter>(RadioButtons_get_SelectedIndex), reinterpret_cast<setter>(RadioButtons_put_SelectedIndex), nullptr, nullptr },
        { "max_columns", reinterpret_cast<getter>(RadioButtons_get_MaxColumns), reinterpret_cast<setter>(RadioButtons_put_MaxColumns), nullptr, nullptr },
        { "items_source", reinterpret_cast<getter>(RadioButtons_get_ItemsSource), reinterpret_cast<setter>(RadioButtons_put_ItemsSource), nullptr, nullptr },
        { "item_template", reinterpret_cast<getter>(RadioButtons_get_ItemTemplate), reinterpret_cast<setter>(RadioButtons_put_ItemTemplate), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(RadioButtons_get_HeaderTemplate), reinterpret_cast<setter>(RadioButtons_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(RadioButtons_get_Header), reinterpret_cast<setter>(RadioButtons_put_Header), nullptr, nullptr },
        { "items", reinterpret_cast<getter>(RadioButtons_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RadioButtons[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RadioButtons) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RadioButtons) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RadioButtons) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RadioButtons) },
        { },
    };

    static PyType_Spec type_spec_RadioButtons =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RadioButtons",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RadioButtons),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RadioButtons
    };

    static PyGetSetDef getset_RadioButtons_Static[] = {
        { "header_property", reinterpret_cast<getter>(RadioButtons_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(RadioButtons_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "item_template_property", reinterpret_cast<getter>(RadioButtons_get_ItemTemplateProperty), nullptr, nullptr, nullptr },
        { "items_property", reinterpret_cast<getter>(RadioButtons_get_ItemsProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(RadioButtons_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { "max_columns_property", reinterpret_cast<getter>(RadioButtons_get_MaxColumnsProperty), nullptr, nullptr, nullptr },
        { "selected_index_property", reinterpret_cast<getter>(RadioButtons_get_SelectedIndexProperty), nullptr, nullptr, nullptr },
        { "selected_item_property", reinterpret_cast<getter>(RadioButtons_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RadioButtons_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RadioButtons_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RadioButtons_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RadioButtons_Static) },
        { }
    };

    static PyType_Spec type_spec_RadioButtons_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RadioButtons_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RadioButtons_Static
    };

    // ----- RadioMenuFlyoutItem class --------------------

    static PyObject* _new_RadioMenuFlyoutItem(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::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem 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_RadioMenuFlyoutItem(py::wrapper::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RadioMenuFlyoutItem_GetAreCheckStatesEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"GetAreCheckStatesEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem::GetAreCheckStatesEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RadioMenuFlyoutItem_SetAreCheckStatesEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"SetAreCheckStatesEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::MenuFlyoutSubItem>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem::SetAreCheckStatesEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RadioMenuFlyoutItem_get_IsChecked(py::wrapper::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"IsChecked"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsChecked());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioMenuFlyoutItem_put_IsChecked(py::wrapper::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"IsChecked"))
        {
            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.IsChecked(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioMenuFlyoutItem_get_GroupName(py::wrapper::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"GroupName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GroupName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RadioMenuFlyoutItem_put_GroupName(py::wrapper::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"GroupName"))
        {
            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.GroupName(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RadioMenuFlyoutItem_get_GroupNameProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"GroupNameProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem::GroupNameProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioMenuFlyoutItem_get_IsCheckedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"IsCheckedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem::IsCheckedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RadioMenuFlyoutItem_get_AreCheckStatesEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem", L"AreCheckStatesEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem::AreCheckStatesEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RadioMenuFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RadioMenuFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RadioMenuFlyoutItem[] = {
        { "_assign_array_", _assign_array_RadioMenuFlyoutItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RadioMenuFlyoutItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RadioMenuFlyoutItem[] = {
        { "is_checked", reinterpret_cast<getter>(RadioMenuFlyoutItem_get_IsChecked), reinterpret_cast<setter>(RadioMenuFlyoutItem_put_IsChecked), nullptr, nullptr },
        { "group_name", reinterpret_cast<getter>(RadioMenuFlyoutItem_get_GroupName), reinterpret_cast<setter>(RadioMenuFlyoutItem_put_GroupName), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RadioMenuFlyoutItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RadioMenuFlyoutItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RadioMenuFlyoutItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RadioMenuFlyoutItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RadioMenuFlyoutItem) },
        { },
    };

    static PyType_Spec type_spec_RadioMenuFlyoutItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RadioMenuFlyoutItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RadioMenuFlyoutItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RadioMenuFlyoutItem
    };

    static PyGetSetDef getset_RadioMenuFlyoutItem_Static[] = {
        { "group_name_property", reinterpret_cast<getter>(RadioMenuFlyoutItem_get_GroupNameProperty), nullptr, nullptr, nullptr },
        { "is_checked_property", reinterpret_cast<getter>(RadioMenuFlyoutItem_get_IsCheckedProperty), nullptr, nullptr, nullptr },
        { "are_check_states_enabled_property", reinterpret_cast<getter>(RadioMenuFlyoutItem_get_AreCheckStatesEnabledProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RadioMenuFlyoutItem_Static[] = {
        { "get_are_check_states_enabled", reinterpret_cast<PyCFunction>(RadioMenuFlyoutItem_GetAreCheckStatesEnabled), METH_VARARGS, nullptr },
        { "set_are_check_states_enabled", reinterpret_cast<PyCFunction>(RadioMenuFlyoutItem_SetAreCheckStatesEnabled), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_RadioMenuFlyoutItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RadioMenuFlyoutItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RadioMenuFlyoutItem_Static) },
        { }
    };

    static PyType_Spec type_spec_RadioMenuFlyoutItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RadioMenuFlyoutItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RadioMenuFlyoutItem_Static
    };

    // ----- RatingControl class --------------------

    static PyObject* _new_RatingControl(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::Microsoft::UI::Xaml::Controls::RatingControl 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_RatingControl(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RatingControl_get_Value(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", 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 RatingControl_put_Value(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", 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<double>(arg);

            self->obj.Value(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_PlaceholderValue(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"PlaceholderValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingControl_put_PlaceholderValue(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"PlaceholderValue"))
        {
            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<double>(arg);

            self->obj.PlaceholderValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_MaxRating(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"MaxRating"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxRating());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingControl_put_MaxRating(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"MaxRating"))
        {
            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<int32_t>(arg);

            self->obj.MaxRating(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_ItemInfo(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"ItemInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingControl_put_ItemInfo(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"ItemInfo"))
        {
            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::Microsoft::UI::Xaml::Controls::RatingItemInfo>(arg);

            self->obj.ItemInfo(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_IsReadOnly(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"IsReadOnly"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsReadOnly());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingControl_put_IsReadOnly(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"IsReadOnly"))
        {
            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.IsReadOnly(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_IsClearEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"IsClearEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsClearEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingControl_put_IsClearEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"IsClearEnabled"))
        {
            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.IsClearEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_InitialSetValue(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"InitialSetValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InitialSetValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingControl_put_InitialSetValue(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"InitialSetValue"))
        {
            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<int32_t>(arg);

            self->obj.InitialSetValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_Caption(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"Caption"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Caption());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingControl_put_Caption(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"Caption"))
        {
            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.Caption(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingControl_get_CaptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"CaptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::CaptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_get_InitialSetValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"InitialSetValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::InitialSetValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_get_IsClearEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"IsClearEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::IsClearEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_get_IsReadOnlyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"IsReadOnlyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::IsReadOnlyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_get_ItemInfoProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"ItemInfoProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::ItemInfoProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_get_MaxRatingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"MaxRatingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::MaxRatingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_get_PlaceholderValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"PlaceholderValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::PlaceholderValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_get_ValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"ValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingControl::ValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_add_ValueChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"ValueChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RatingControl, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ValueChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingControl_remove_ValueChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RatingControl", L"ValueChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ValueChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RatingControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RatingControl>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RatingControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RatingControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RatingControl[] = {
        { "add_value_changed", reinterpret_cast<PyCFunction>(RatingControl_add_ValueChanged), METH_O, nullptr },
        { "remove_value_changed", reinterpret_cast<PyCFunction>(RatingControl_remove_ValueChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_RatingControl, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RatingControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RatingControl[] = {
        { "value", reinterpret_cast<getter>(RatingControl_get_Value), reinterpret_cast<setter>(RatingControl_put_Value), nullptr, nullptr },
        { "placeholder_value", reinterpret_cast<getter>(RatingControl_get_PlaceholderValue), reinterpret_cast<setter>(RatingControl_put_PlaceholderValue), nullptr, nullptr },
        { "max_rating", reinterpret_cast<getter>(RatingControl_get_MaxRating), reinterpret_cast<setter>(RatingControl_put_MaxRating), nullptr, nullptr },
        { "item_info", reinterpret_cast<getter>(RatingControl_get_ItemInfo), reinterpret_cast<setter>(RatingControl_put_ItemInfo), nullptr, nullptr },
        { "is_read_only", reinterpret_cast<getter>(RatingControl_get_IsReadOnly), reinterpret_cast<setter>(RatingControl_put_IsReadOnly), nullptr, nullptr },
        { "is_clear_enabled", reinterpret_cast<getter>(RatingControl_get_IsClearEnabled), reinterpret_cast<setter>(RatingControl_put_IsClearEnabled), nullptr, nullptr },
        { "initial_set_value", reinterpret_cast<getter>(RatingControl_get_InitialSetValue), reinterpret_cast<setter>(RatingControl_put_InitialSetValue), nullptr, nullptr },
        { "caption", reinterpret_cast<getter>(RatingControl_get_Caption), reinterpret_cast<setter>(RatingControl_put_Caption), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RatingControl[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RatingControl) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RatingControl) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RatingControl) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RatingControl) },
        { },
    };

    static PyType_Spec type_spec_RatingControl =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RatingControl",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RatingControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RatingControl
    };

    static PyGetSetDef getset_RatingControl_Static[] = {
        { "caption_property", reinterpret_cast<getter>(RatingControl_get_CaptionProperty), nullptr, nullptr, nullptr },
        { "initial_set_value_property", reinterpret_cast<getter>(RatingControl_get_InitialSetValueProperty), nullptr, nullptr, nullptr },
        { "is_clear_enabled_property", reinterpret_cast<getter>(RatingControl_get_IsClearEnabledProperty), nullptr, nullptr, nullptr },
        { "is_read_only_property", reinterpret_cast<getter>(RatingControl_get_IsReadOnlyProperty), nullptr, nullptr, nullptr },
        { "item_info_property", reinterpret_cast<getter>(RatingControl_get_ItemInfoProperty), nullptr, nullptr, nullptr },
        { "max_rating_property", reinterpret_cast<getter>(RatingControl_get_MaxRatingProperty), nullptr, nullptr, nullptr },
        { "placeholder_value_property", reinterpret_cast<getter>(RatingControl_get_PlaceholderValueProperty), nullptr, nullptr, nullptr },
        { "value_property", reinterpret_cast<getter>(RatingControl_get_ValueProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RatingControl_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RatingControl_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RatingControl_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RatingControl_Static) },
        { }
    };

    static PyType_Spec type_spec_RatingControl_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RatingControl_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RatingControl_Static
    };

    // ----- RatingItemFontInfo class --------------------

    static PyObject* _new_RatingItemFontInfo(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::Microsoft::UI::Xaml::Controls::RatingItemFontInfo 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_RatingItemFontInfo(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RatingItemFontInfo_get_UnsetGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"UnsetGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.UnsetGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemFontInfo_put_UnsetGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"UnsetGlyph"))
        {
            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.UnsetGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemFontInfo_get_PointerOverPlaceholderGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PointerOverPlaceholderGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PointerOverPlaceholderGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemFontInfo_put_PointerOverPlaceholderGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PointerOverPlaceholderGlyph"))
        {
            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.PointerOverPlaceholderGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemFontInfo_get_PointerOverGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PointerOverGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PointerOverGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemFontInfo_put_PointerOverGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PointerOverGlyph"))
        {
            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.PointerOverGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemFontInfo_get_PlaceholderGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PlaceholderGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemFontInfo_put_PlaceholderGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PlaceholderGlyph"))
        {
            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.PlaceholderGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemFontInfo_get_Glyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"Glyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Glyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemFontInfo_put_Glyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"Glyph"))
        {
            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.Glyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemFontInfo_get_DisabledGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"DisabledGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisabledGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemFontInfo_put_DisabledGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"DisabledGlyph"))
        {
            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.DisabledGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemFontInfo_get_DisabledGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"DisabledGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo::DisabledGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemFontInfo_get_GlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"GlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo::GlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemFontInfo_get_PlaceholderGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PlaceholderGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo::PlaceholderGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemFontInfo_get_PointerOverGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PointerOverGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo::PointerOverGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemFontInfo_get_PointerOverPlaceholderGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"PointerOverPlaceholderGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo::PointerOverPlaceholderGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemFontInfo_get_UnsetGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemFontInfo", L"UnsetGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo::UnsetGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RatingItemFontInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RatingItemFontInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RatingItemFontInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RatingItemFontInfo[] = {
        { "_assign_array_", _assign_array_RatingItemFontInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RatingItemFontInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RatingItemFontInfo[] = {
        { "unset_glyph", reinterpret_cast<getter>(RatingItemFontInfo_get_UnsetGlyph), reinterpret_cast<setter>(RatingItemFontInfo_put_UnsetGlyph), nullptr, nullptr },
        { "pointer_over_placeholder_glyph", reinterpret_cast<getter>(RatingItemFontInfo_get_PointerOverPlaceholderGlyph), reinterpret_cast<setter>(RatingItemFontInfo_put_PointerOverPlaceholderGlyph), nullptr, nullptr },
        { "pointer_over_glyph", reinterpret_cast<getter>(RatingItemFontInfo_get_PointerOverGlyph), reinterpret_cast<setter>(RatingItemFontInfo_put_PointerOverGlyph), nullptr, nullptr },
        { "placeholder_glyph", reinterpret_cast<getter>(RatingItemFontInfo_get_PlaceholderGlyph), reinterpret_cast<setter>(RatingItemFontInfo_put_PlaceholderGlyph), nullptr, nullptr },
        { "glyph", reinterpret_cast<getter>(RatingItemFontInfo_get_Glyph), reinterpret_cast<setter>(RatingItemFontInfo_put_Glyph), nullptr, nullptr },
        { "disabled_glyph", reinterpret_cast<getter>(RatingItemFontInfo_get_DisabledGlyph), reinterpret_cast<setter>(RatingItemFontInfo_put_DisabledGlyph), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RatingItemFontInfo[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RatingItemFontInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RatingItemFontInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RatingItemFontInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RatingItemFontInfo) },
        { },
    };

    static PyType_Spec type_spec_RatingItemFontInfo =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RatingItemFontInfo",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemFontInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RatingItemFontInfo
    };

    static PyGetSetDef getset_RatingItemFontInfo_Static[] = {
        { "disabled_glyph_property", reinterpret_cast<getter>(RatingItemFontInfo_get_DisabledGlyphProperty), nullptr, nullptr, nullptr },
        { "glyph_property", reinterpret_cast<getter>(RatingItemFontInfo_get_GlyphProperty), nullptr, nullptr, nullptr },
        { "placeholder_glyph_property", reinterpret_cast<getter>(RatingItemFontInfo_get_PlaceholderGlyphProperty), nullptr, nullptr, nullptr },
        { "pointer_over_glyph_property", reinterpret_cast<getter>(RatingItemFontInfo_get_PointerOverGlyphProperty), nullptr, nullptr, nullptr },
        { "pointer_over_placeholder_glyph_property", reinterpret_cast<getter>(RatingItemFontInfo_get_PointerOverPlaceholderGlyphProperty), nullptr, nullptr, nullptr },
        { "unset_glyph_property", reinterpret_cast<getter>(RatingItemFontInfo_get_UnsetGlyphProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RatingItemFontInfo_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RatingItemFontInfo_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RatingItemFontInfo_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RatingItemFontInfo_Static) },
        { }
    };

    static PyType_Spec type_spec_RatingItemFontInfo_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RatingItemFontInfo_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RatingItemFontInfo_Static
    };

    // ----- RatingItemImageInfo class --------------------

    static PyObject* _new_RatingItemImageInfo(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::Microsoft::UI::Xaml::Controls::RatingItemImageInfo 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_RatingItemImageInfo(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RatingItemImageInfo_get_UnsetImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"UnsetImage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.UnsetImage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemImageInfo_put_UnsetImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"UnsetImage"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.UnsetImage(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemImageInfo_get_PointerOverPlaceholderImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PointerOverPlaceholderImage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PointerOverPlaceholderImage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemImageInfo_put_PointerOverPlaceholderImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PointerOverPlaceholderImage"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.PointerOverPlaceholderImage(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemImageInfo_get_PointerOverImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PointerOverImage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PointerOverImage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemImageInfo_put_PointerOverImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PointerOverImage"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.PointerOverImage(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemImageInfo_get_PlaceholderImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PlaceholderImage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderImage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemImageInfo_put_PlaceholderImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PlaceholderImage"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.PlaceholderImage(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemImageInfo_get_Image(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"Image"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Image());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemImageInfo_put_Image(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"Image"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.Image(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemImageInfo_get_DisabledImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"DisabledImage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisabledImage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RatingItemImageInfo_put_DisabledImage(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"DisabledImage"))
        {
            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::Microsoft::UI::Xaml::Media::ImageSource>(arg);

            self->obj.DisabledImage(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RatingItemImageInfo_get_DisabledImageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"DisabledImageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo::DisabledImageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemImageInfo_get_ImageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"ImageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo::ImageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemImageInfo_get_PlaceholderImageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PlaceholderImageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo::PlaceholderImageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemImageInfo_get_PointerOverImageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PointerOverImageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo::PointerOverImageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemImageInfo_get_PointerOverPlaceholderImageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"PointerOverPlaceholderImageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo::PointerOverPlaceholderImageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RatingItemImageInfo_get_UnsetImageProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RatingItemImageInfo", L"UnsetImageProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo::UnsetImageProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RatingItemImageInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RatingItemImageInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RatingItemImageInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RatingItemImageInfo[] = {
        { "_assign_array_", _assign_array_RatingItemImageInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RatingItemImageInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RatingItemImageInfo[] = {
        { "unset_image", reinterpret_cast<getter>(RatingItemImageInfo_get_UnsetImage), reinterpret_cast<setter>(RatingItemImageInfo_put_UnsetImage), nullptr, nullptr },
        { "pointer_over_placeholder_image", reinterpret_cast<getter>(RatingItemImageInfo_get_PointerOverPlaceholderImage), reinterpret_cast<setter>(RatingItemImageInfo_put_PointerOverPlaceholderImage), nullptr, nullptr },
        { "pointer_over_image", reinterpret_cast<getter>(RatingItemImageInfo_get_PointerOverImage), reinterpret_cast<setter>(RatingItemImageInfo_put_PointerOverImage), nullptr, nullptr },
        { "placeholder_image", reinterpret_cast<getter>(RatingItemImageInfo_get_PlaceholderImage), reinterpret_cast<setter>(RatingItemImageInfo_put_PlaceholderImage), nullptr, nullptr },
        { "image", reinterpret_cast<getter>(RatingItemImageInfo_get_Image), reinterpret_cast<setter>(RatingItemImageInfo_put_Image), nullptr, nullptr },
        { "disabled_image", reinterpret_cast<getter>(RatingItemImageInfo_get_DisabledImage), reinterpret_cast<setter>(RatingItemImageInfo_put_DisabledImage), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RatingItemImageInfo[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RatingItemImageInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RatingItemImageInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RatingItemImageInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RatingItemImageInfo) },
        { },
    };

    static PyType_Spec type_spec_RatingItemImageInfo =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RatingItemImageInfo",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemImageInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RatingItemImageInfo
    };

    static PyGetSetDef getset_RatingItemImageInfo_Static[] = {
        { "disabled_image_property", reinterpret_cast<getter>(RatingItemImageInfo_get_DisabledImageProperty), nullptr, nullptr, nullptr },
        { "image_property", reinterpret_cast<getter>(RatingItemImageInfo_get_ImageProperty), nullptr, nullptr, nullptr },
        { "placeholder_image_property", reinterpret_cast<getter>(RatingItemImageInfo_get_PlaceholderImageProperty), nullptr, nullptr, nullptr },
        { "pointer_over_image_property", reinterpret_cast<getter>(RatingItemImageInfo_get_PointerOverImageProperty), nullptr, nullptr, nullptr },
        { "pointer_over_placeholder_image_property", reinterpret_cast<getter>(RatingItemImageInfo_get_PointerOverPlaceholderImageProperty), nullptr, nullptr, nullptr },
        { "unset_image_property", reinterpret_cast<getter>(RatingItemImageInfo_get_UnsetImageProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RatingItemImageInfo_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RatingItemImageInfo_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RatingItemImageInfo_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RatingItemImageInfo_Static) },
        { }
    };

    static PyType_Spec type_spec_RatingItemImageInfo_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RatingItemImageInfo_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RatingItemImageInfo_Static
    };

    // ----- RatingItemInfo class --------------------

    static PyObject* _new_RatingItemInfo(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::Microsoft::UI::Xaml::Controls::RatingItemInfo 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_RatingItemInfo(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemInfo* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_RatingItemInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RatingItemInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RatingItemInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RatingItemInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RatingItemInfo[] = {
        { "_assign_array_", _assign_array_RatingItemInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RatingItemInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RatingItemInfo[] = {
        { }
    };

    static PyType_Slot _type_slots_RatingItemInfo[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RatingItemInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RatingItemInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RatingItemInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RatingItemInfo) },
        { },
    };

    static PyType_Spec type_spec_RatingItemInfo =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RatingItemInfo",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RatingItemInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RatingItemInfo
    };

    // ----- RefreshContainer class --------------------

    static PyObject* _new_RefreshContainer(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::Microsoft::UI::Xaml::Controls::RefreshContainer 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_RefreshContainer(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RefreshContainer_RequestRefresh(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"RequestRefresh", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RequestRefresh();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RefreshContainer_get_Visualizer(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"Visualizer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Visualizer());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RefreshContainer_put_Visualizer(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"Visualizer"))
        {
            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::Microsoft::UI::Xaml::Controls::RefreshVisualizer>(arg);

            self->obj.Visualizer(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RefreshContainer_get_PullDirection(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"PullDirection"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PullDirection());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RefreshContainer_put_PullDirection(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"PullDirection"))
        {
            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::Microsoft::UI::Xaml::Controls::RefreshPullDirection>(arg);

            self->obj.PullDirection(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RefreshContainer_get_PullDirectionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"PullDirectionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RefreshContainer::PullDirectionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshContainer_get_VisualizerProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"VisualizerProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RefreshContainer::VisualizerProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshContainer_add_RefreshRequested(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"RefreshRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RefreshContainer, winrt::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs>>(arg);

            return py::convert(self->obj.RefreshRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshContainer_remove_RefreshRequested(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RefreshContainer", L"RefreshRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.RefreshRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RefreshContainer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RefreshContainer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RefreshContainer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RefreshContainer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RefreshContainer[] = {
        { "request_refresh", reinterpret_cast<PyCFunction>(RefreshContainer_RequestRefresh), METH_VARARGS, nullptr },
        { "add_refresh_requested", reinterpret_cast<PyCFunction>(RefreshContainer_add_RefreshRequested), METH_O, nullptr },
        { "remove_refresh_requested", reinterpret_cast<PyCFunction>(RefreshContainer_remove_RefreshRequested), METH_O, nullptr },
        { "_assign_array_", _assign_array_RefreshContainer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RefreshContainer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RefreshContainer[] = {
        { "visualizer", reinterpret_cast<getter>(RefreshContainer_get_Visualizer), reinterpret_cast<setter>(RefreshContainer_put_Visualizer), nullptr, nullptr },
        { "pull_direction", reinterpret_cast<getter>(RefreshContainer_get_PullDirection), reinterpret_cast<setter>(RefreshContainer_put_PullDirection), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RefreshContainer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RefreshContainer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RefreshContainer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RefreshContainer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RefreshContainer) },
        { },
    };

    static PyType_Spec type_spec_RefreshContainer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RefreshContainer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshContainer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RefreshContainer
    };

    static PyGetSetDef getset_RefreshContainer_Static[] = {
        { "pull_direction_property", reinterpret_cast<getter>(RefreshContainer_get_PullDirectionProperty), nullptr, nullptr, nullptr },
        { "visualizer_property", reinterpret_cast<getter>(RefreshContainer_get_VisualizerProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RefreshContainer_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RefreshContainer_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RefreshContainer_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RefreshContainer_Static) },
        { }
    };

    static PyType_Spec type_spec_RefreshContainer_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RefreshContainer_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RefreshContainer_Static
    };

    // ----- RefreshInteractionRatioChangedEventArgs class --------------------

    static PyObject* _new_RefreshInteractionRatioChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RefreshInteractionRatioChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RefreshInteractionRatioChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_RefreshInteractionRatioChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshInteractionRatioChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RefreshInteractionRatioChangedEventArgs_get_InteractionRatio(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshInteractionRatioChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshInteractionRatioChangedEventArgs", L"InteractionRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InteractionRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RefreshInteractionRatioChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RefreshInteractionRatioChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RefreshInteractionRatioChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RefreshInteractionRatioChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RefreshInteractionRatioChangedEventArgs[] = {
        { "_assign_array_", _assign_array_RefreshInteractionRatioChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RefreshInteractionRatioChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RefreshInteractionRatioChangedEventArgs[] = {
        { "interaction_ratio", reinterpret_cast<getter>(RefreshInteractionRatioChangedEventArgs_get_InteractionRatio), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RefreshInteractionRatioChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RefreshInteractionRatioChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RefreshInteractionRatioChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RefreshInteractionRatioChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RefreshInteractionRatioChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_RefreshInteractionRatioChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RefreshInteractionRatioChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshInteractionRatioChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RefreshInteractionRatioChangedEventArgs
    };

    // ----- RefreshRequestedEventArgs class --------------------

    static PyObject* _new_RefreshRequestedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_RefreshRequestedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RefreshRequestedEventArgs_GetDeferral(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RefreshRequestedEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetDeferral());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_RefreshRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RefreshRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RefreshRequestedEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(RefreshRequestedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_RefreshRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RefreshRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RefreshRequestedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_RefreshRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RefreshRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RefreshRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RefreshRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RefreshRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_RefreshRequestedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RefreshRequestedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RefreshRequestedEventArgs
    };

    // ----- RefreshStateChangedEventArgs class --------------------

    static PyObject* _new_RefreshStateChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_RefreshStateChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RefreshStateChangedEventArgs_get_NewState(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshStateChangedEventArgs", L"NewState"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewState());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshStateChangedEventArgs_get_OldState(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshStateChangedEventArgs", L"OldState"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OldState());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RefreshStateChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RefreshStateChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RefreshStateChangedEventArgs[] = {
        { "_assign_array_", _assign_array_RefreshStateChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RefreshStateChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RefreshStateChangedEventArgs[] = {
        { "new_state", reinterpret_cast<getter>(RefreshStateChangedEventArgs_get_NewState), nullptr, nullptr, nullptr },
        { "old_state", reinterpret_cast<getter>(RefreshStateChangedEventArgs_get_OldState), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RefreshStateChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RefreshStateChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RefreshStateChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RefreshStateChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RefreshStateChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_RefreshStateChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RefreshStateChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RefreshStateChangedEventArgs
    };

    // ----- RefreshVisualizer class --------------------

    static PyObject* _new_RefreshVisualizer(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::Microsoft::UI::Xaml::Controls::RefreshVisualizer 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_RefreshVisualizer(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RefreshVisualizer_RequestRefresh(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"RequestRefresh", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RequestRefresh();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RefreshVisualizer_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::RefreshVisualizerOrientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RefreshVisualizer_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RefreshVisualizer_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"Content"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RefreshVisualizer_get_State(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"State"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.State());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_get_InfoProviderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"InfoProviderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer::InfoProviderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_get_StateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"StateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer::StateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_add_RefreshRequested(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"RefreshRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer, winrt::Microsoft::UI::Xaml::Controls::RefreshRequestedEventArgs>>(arg);

            return py::convert(self->obj.RefreshRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_remove_RefreshRequested(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"RefreshRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.RefreshRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_add_RefreshStateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"RefreshStateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer, winrt::Microsoft::UI::Xaml::Controls::RefreshStateChangedEventArgs>>(arg);

            return py::convert(self->obj.RefreshStateChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RefreshVisualizer_remove_RefreshStateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RefreshVisualizer", L"RefreshStateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.RefreshStateChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RefreshVisualizer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RefreshVisualizer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RefreshVisualizer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RefreshVisualizer[] = {
        { "request_refresh", reinterpret_cast<PyCFunction>(RefreshVisualizer_RequestRefresh), METH_VARARGS, nullptr },
        { "add_refresh_requested", reinterpret_cast<PyCFunction>(RefreshVisualizer_add_RefreshRequested), METH_O, nullptr },
        { "remove_refresh_requested", reinterpret_cast<PyCFunction>(RefreshVisualizer_remove_RefreshRequested), METH_O, nullptr },
        { "add_refresh_state_changed", reinterpret_cast<PyCFunction>(RefreshVisualizer_add_RefreshStateChanged), METH_O, nullptr },
        { "remove_refresh_state_changed", reinterpret_cast<PyCFunction>(RefreshVisualizer_remove_RefreshStateChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_RefreshVisualizer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RefreshVisualizer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RefreshVisualizer[] = {
        { "orientation", reinterpret_cast<getter>(RefreshVisualizer_get_Orientation), reinterpret_cast<setter>(RefreshVisualizer_put_Orientation), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(RefreshVisualizer_get_Content), reinterpret_cast<setter>(RefreshVisualizer_put_Content), nullptr, nullptr },
        { "state", reinterpret_cast<getter>(RefreshVisualizer_get_State), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RefreshVisualizer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RefreshVisualizer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RefreshVisualizer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RefreshVisualizer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RefreshVisualizer) },
        { },
    };

    static PyType_Spec type_spec_RefreshVisualizer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RefreshVisualizer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RefreshVisualizer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RefreshVisualizer
    };

    static PyGetSetDef getset_RefreshVisualizer_Static[] = {
        { "content_property", reinterpret_cast<getter>(RefreshVisualizer_get_ContentProperty), nullptr, nullptr, nullptr },
        { "info_provider_property", reinterpret_cast<getter>(RefreshVisualizer_get_InfoProviderProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(RefreshVisualizer_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "state_property", reinterpret_cast<getter>(RefreshVisualizer_get_StateProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RefreshVisualizer_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RefreshVisualizer_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RefreshVisualizer_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RefreshVisualizer_Static) },
        { }
    };

    static PyType_Spec type_spec_RefreshVisualizer_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RefreshVisualizer_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RefreshVisualizer_Static
    };

    // ----- RelativePanel class --------------------

    static PyObject* _new_RelativePanel(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::Microsoft::UI::Xaml::Controls::RelativePanel 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_RelativePanel(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RelativePanel_GetAbove(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAbove", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAbove(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignBottomWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignBottomWith", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignBottomWith(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignBottomWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignBottomWithPanel", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignBottomWithPanel(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignHorizontalCenterWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignHorizontalCenterWith", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignHorizontalCenterWith(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignHorizontalCenterWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignHorizontalCenterWithPanel", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignHorizontalCenterWithPanel(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignLeftWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignLeftWith", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignLeftWith(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignLeftWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignLeftWithPanel", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignLeftWithPanel(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignRightWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignRightWith", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignRightWith(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignRightWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignRightWithPanel", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignRightWithPanel(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignTopWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignTopWith", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignTopWith(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignTopWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignTopWithPanel", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignTopWithPanel(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignVerticalCenterWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignVerticalCenterWith", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignVerticalCenterWith(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetAlignVerticalCenterWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetAlignVerticalCenterWithPanel", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetAlignVerticalCenterWithPanel(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetBelow(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetBelow", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetBelow(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetLeftOf(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetLeftOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetLeftOf(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_GetRightOf(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"GetRightOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::GetRightOf(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAbove(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAbove", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAbove(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignBottomWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignBottomWith", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignBottomWith(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignBottomWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignBottomWithPanel", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignBottomWithPanel(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignHorizontalCenterWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignHorizontalCenterWith", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignHorizontalCenterWith(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignHorizontalCenterWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignHorizontalCenterWithPanel", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignHorizontalCenterWithPanel(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignLeftWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignLeftWith", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignLeftWith(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignLeftWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignLeftWithPanel", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignLeftWithPanel(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignRightWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignRightWith", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignRightWith(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignRightWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignRightWithPanel", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignRightWithPanel(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignTopWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignTopWith", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignTopWith(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignTopWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignTopWithPanel", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignTopWithPanel(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignVerticalCenterWith(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignVerticalCenterWith", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignVerticalCenterWith(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetAlignVerticalCenterWithPanel(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetAlignVerticalCenterWithPanel", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetAlignVerticalCenterWithPanel(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetBelow(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetBelow", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetBelow(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetLeftOf(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetLeftOf", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetLeftOf(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_SetRightOf(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"SetRightOf", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::RelativePanel::SetRightOf(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Padding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RelativePanel_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.Padding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RelativePanel_get_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"CornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CornerRadius());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RelativePanel_put_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"CornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

            self->obj.CornerRadius(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RelativePanel_get_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BorderThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BorderThickness());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RelativePanel_put_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BorderThickness"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.BorderThickness(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RelativePanel_get_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BorderBrush());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RelativePanel_put_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.BorderBrush(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RelativePanel_get_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BackgroundSizing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BackgroundSizing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RelativePanel_put_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BackgroundSizing"))
        {
            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::Microsoft::UI::Xaml::Controls::BackgroundSizing>(arg);

            self->obj.BackgroundSizing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RelativePanel_get_AboveProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AboveProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AboveProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignBottomWithPanelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignBottomWithPanelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignBottomWithPanelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignBottomWithProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignBottomWithProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignBottomWithProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignHorizontalCenterWithPanelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignHorizontalCenterWithPanelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignHorizontalCenterWithPanelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignHorizontalCenterWithProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignHorizontalCenterWithProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignHorizontalCenterWithProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignLeftWithPanelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignLeftWithPanelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignLeftWithPanelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignLeftWithProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignLeftWithProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignLeftWithProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignRightWithPanelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignRightWithPanelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignRightWithPanelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignRightWithProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignRightWithProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignRightWithProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignTopWithPanelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignTopWithPanelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignTopWithPanelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignTopWithProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignTopWithProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignTopWithProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignVerticalCenterWithPanelProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignVerticalCenterWithPanelProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignVerticalCenterWithPanelProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_AlignVerticalCenterWithProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"AlignVerticalCenterWithProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::AlignVerticalCenterWithProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_BackgroundSizingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BackgroundSizingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::BackgroundSizingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_BelowProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BelowProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::BelowProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_BorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::BorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_BorderThicknessProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"BorderThicknessProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::BorderThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_CornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"CornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::CornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_LeftOfProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"LeftOfProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::LeftOfProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RelativePanel_get_RightOfProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RelativePanel", L"RightOfProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RelativePanel::RightOfProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RelativePanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RelativePanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RelativePanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RelativePanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RelativePanel[] = {
        { "_assign_array_", _assign_array_RelativePanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RelativePanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RelativePanel[] = {
        { "padding", reinterpret_cast<getter>(RelativePanel_get_Padding), reinterpret_cast<setter>(RelativePanel_put_Padding), nullptr, nullptr },
        { "corner_radius", reinterpret_cast<getter>(RelativePanel_get_CornerRadius), reinterpret_cast<setter>(RelativePanel_put_CornerRadius), nullptr, nullptr },
        { "border_thickness", reinterpret_cast<getter>(RelativePanel_get_BorderThickness), reinterpret_cast<setter>(RelativePanel_put_BorderThickness), nullptr, nullptr },
        { "border_brush", reinterpret_cast<getter>(RelativePanel_get_BorderBrush), reinterpret_cast<setter>(RelativePanel_put_BorderBrush), nullptr, nullptr },
        { "background_sizing", reinterpret_cast<getter>(RelativePanel_get_BackgroundSizing), reinterpret_cast<setter>(RelativePanel_put_BackgroundSizing), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RelativePanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RelativePanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RelativePanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RelativePanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RelativePanel) },
        { },
    };

    static PyType_Spec type_spec_RelativePanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RelativePanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RelativePanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RelativePanel
    };

    static PyGetSetDef getset_RelativePanel_Static[] = {
        { "above_property", reinterpret_cast<getter>(RelativePanel_get_AboveProperty), nullptr, nullptr, nullptr },
        { "align_bottom_with_panel_property", reinterpret_cast<getter>(RelativePanel_get_AlignBottomWithPanelProperty), nullptr, nullptr, nullptr },
        { "align_bottom_with_property", reinterpret_cast<getter>(RelativePanel_get_AlignBottomWithProperty), nullptr, nullptr, nullptr },
        { "align_horizontal_center_with_panel_property", reinterpret_cast<getter>(RelativePanel_get_AlignHorizontalCenterWithPanelProperty), nullptr, nullptr, nullptr },
        { "align_horizontal_center_with_property", reinterpret_cast<getter>(RelativePanel_get_AlignHorizontalCenterWithProperty), nullptr, nullptr, nullptr },
        { "align_left_with_panel_property", reinterpret_cast<getter>(RelativePanel_get_AlignLeftWithPanelProperty), nullptr, nullptr, nullptr },
        { "align_left_with_property", reinterpret_cast<getter>(RelativePanel_get_AlignLeftWithProperty), nullptr, nullptr, nullptr },
        { "align_right_with_panel_property", reinterpret_cast<getter>(RelativePanel_get_AlignRightWithPanelProperty), nullptr, nullptr, nullptr },
        { "align_right_with_property", reinterpret_cast<getter>(RelativePanel_get_AlignRightWithProperty), nullptr, nullptr, nullptr },
        { "align_top_with_panel_property", reinterpret_cast<getter>(RelativePanel_get_AlignTopWithPanelProperty), nullptr, nullptr, nullptr },
        { "align_top_with_property", reinterpret_cast<getter>(RelativePanel_get_AlignTopWithProperty), nullptr, nullptr, nullptr },
        { "align_vertical_center_with_panel_property", reinterpret_cast<getter>(RelativePanel_get_AlignVerticalCenterWithPanelProperty), nullptr, nullptr, nullptr },
        { "align_vertical_center_with_property", reinterpret_cast<getter>(RelativePanel_get_AlignVerticalCenterWithProperty), nullptr, nullptr, nullptr },
        { "background_sizing_property", reinterpret_cast<getter>(RelativePanel_get_BackgroundSizingProperty), nullptr, nullptr, nullptr },
        { "below_property", reinterpret_cast<getter>(RelativePanel_get_BelowProperty), nullptr, nullptr, nullptr },
        { "border_brush_property", reinterpret_cast<getter>(RelativePanel_get_BorderBrushProperty), nullptr, nullptr, nullptr },
        { "border_thickness_property", reinterpret_cast<getter>(RelativePanel_get_BorderThicknessProperty), nullptr, nullptr, nullptr },
        { "corner_radius_property", reinterpret_cast<getter>(RelativePanel_get_CornerRadiusProperty), nullptr, nullptr, nullptr },
        { "left_of_property", reinterpret_cast<getter>(RelativePanel_get_LeftOfProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(RelativePanel_get_PaddingProperty), nullptr, nullptr, nullptr },
        { "right_of_property", reinterpret_cast<getter>(RelativePanel_get_RightOfProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RelativePanel_Static[] = {
        { "get_above", reinterpret_cast<PyCFunction>(RelativePanel_GetAbove), METH_VARARGS, nullptr },
        { "get_align_bottom_with", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignBottomWith), METH_VARARGS, nullptr },
        { "get_align_bottom_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignBottomWithPanel), METH_VARARGS, nullptr },
        { "get_align_horizontal_center_with", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignHorizontalCenterWith), METH_VARARGS, nullptr },
        { "get_align_horizontal_center_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignHorizontalCenterWithPanel), METH_VARARGS, nullptr },
        { "get_align_left_with", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignLeftWith), METH_VARARGS, nullptr },
        { "get_align_left_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignLeftWithPanel), METH_VARARGS, nullptr },
        { "get_align_right_with", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignRightWith), METH_VARARGS, nullptr },
        { "get_align_right_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignRightWithPanel), METH_VARARGS, nullptr },
        { "get_align_top_with", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignTopWith), METH_VARARGS, nullptr },
        { "get_align_top_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignTopWithPanel), METH_VARARGS, nullptr },
        { "get_align_vertical_center_with", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignVerticalCenterWith), METH_VARARGS, nullptr },
        { "get_align_vertical_center_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_GetAlignVerticalCenterWithPanel), METH_VARARGS, nullptr },
        { "get_below", reinterpret_cast<PyCFunction>(RelativePanel_GetBelow), METH_VARARGS, nullptr },
        { "get_left_of", reinterpret_cast<PyCFunction>(RelativePanel_GetLeftOf), METH_VARARGS, nullptr },
        { "get_right_of", reinterpret_cast<PyCFunction>(RelativePanel_GetRightOf), METH_VARARGS, nullptr },
        { "set_above", reinterpret_cast<PyCFunction>(RelativePanel_SetAbove), METH_VARARGS, nullptr },
        { "set_align_bottom_with", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignBottomWith), METH_VARARGS, nullptr },
        { "set_align_bottom_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignBottomWithPanel), METH_VARARGS, nullptr },
        { "set_align_horizontal_center_with", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignHorizontalCenterWith), METH_VARARGS, nullptr },
        { "set_align_horizontal_center_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignHorizontalCenterWithPanel), METH_VARARGS, nullptr },
        { "set_align_left_with", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignLeftWith), METH_VARARGS, nullptr },
        { "set_align_left_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignLeftWithPanel), METH_VARARGS, nullptr },
        { "set_align_right_with", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignRightWith), METH_VARARGS, nullptr },
        { "set_align_right_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignRightWithPanel), METH_VARARGS, nullptr },
        { "set_align_top_with", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignTopWith), METH_VARARGS, nullptr },
        { "set_align_top_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignTopWithPanel), METH_VARARGS, nullptr },
        { "set_align_vertical_center_with", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignVerticalCenterWith), METH_VARARGS, nullptr },
        { "set_align_vertical_center_with_panel", reinterpret_cast<PyCFunction>(RelativePanel_SetAlignVerticalCenterWithPanel), METH_VARARGS, nullptr },
        { "set_below", reinterpret_cast<PyCFunction>(RelativePanel_SetBelow), METH_VARARGS, nullptr },
        { "set_left_of", reinterpret_cast<PyCFunction>(RelativePanel_SetLeftOf), METH_VARARGS, nullptr },
        { "set_right_of", reinterpret_cast<PyCFunction>(RelativePanel_SetRightOf), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_RelativePanel_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RelativePanel_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RelativePanel_Static) },
        { }
    };

    static PyType_Spec type_spec_RelativePanel_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RelativePanel_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RelativePanel_Static
    };

    // ----- RevealListViewItemPresenter class --------------------

    static PyObject* _new_RevealListViewItemPresenter(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::Microsoft::UI::Xaml::Controls::RevealListViewItemPresenter 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_RevealListViewItemPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::RevealListViewItemPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_RevealListViewItemPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RevealListViewItemPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RevealListViewItemPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RevealListViewItemPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RevealListViewItemPresenter[] = {
        { "_assign_array_", _assign_array_RevealListViewItemPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RevealListViewItemPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RevealListViewItemPresenter[] = {
        { }
    };

    static PyType_Slot _type_slots_RevealListViewItemPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RevealListViewItemPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RevealListViewItemPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RevealListViewItemPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RevealListViewItemPresenter) },
        { },
    };

    static PyType_Spec type_spec_RevealListViewItemPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RevealListViewItemPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RevealListViewItemPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RevealListViewItemPresenter
    };

    // ----- RichEditBox class --------------------

    static PyObject* _new_RichEditBox(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::Microsoft::UI::Xaml::Controls::RichEditBox 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_RichEditBox(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RichEditBox_GetLinguisticAlternativesAsync(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"GetLinguisticAlternativesAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetLinguisticAlternativesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextWrapping"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextWrapping());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextWrapping"))
        {
            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::Microsoft::UI::Xaml::TextWrapping>(arg);

            self->obj.TextWrapping(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextReadingOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextReadingOrder());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextReadingOrder"))
        {
            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::Microsoft::UI::Xaml::TextReadingOrder>(arg);

            self->obj.TextReadingOrder(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.TextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_SelectionHighlightColorWhenNotFocused(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionHighlightColorWhenNotFocused"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColorWhenNotFocused());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_SelectionHighlightColorWhenNotFocused(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionHighlightColorWhenNotFocused"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColorWhenNotFocused(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionHighlightColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionHighlightColor"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionFlyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

            self->obj.SelectionFlyout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreventKeyboardDisplayOnProgrammaticFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            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.PreventKeyboardDisplayOnProgrammaticFocus(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"PlaceholderText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"PlaceholderText"))
        {
            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.PlaceholderText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_MaxLength(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"MaxLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_MaxLength(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"MaxLength"))
        {
            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<int32_t>(arg);

            self->obj.MaxLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_IsTextPredictionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsTextPredictionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextPredictionEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_IsTextPredictionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsTextPredictionEnabled"))
        {
            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.IsTextPredictionEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_IsSpellCheckEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsSpellCheckEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSpellCheckEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_IsSpellCheckEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsSpellCheckEnabled"))
        {
            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.IsSpellCheckEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_IsReadOnly(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsReadOnly"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsReadOnly());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_IsReadOnly(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsReadOnly"))
        {
            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.IsReadOnly(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsColorFontEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsColorFontEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsColorFontEnabled"))
        {
            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.IsColorFontEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_InputScope(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"InputScope"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InputScope());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_InputScope(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"InputScope"))
        {
            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::Microsoft::UI::Xaml::Input::InputScope>(arg);

            self->obj.InputScope(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"HorizontalTextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalTextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"HorizontalTextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.HorizontalTextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_DisabledFormattingAccelerators(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"DisabledFormattingAccelerators"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisabledFormattingAccelerators());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_DisabledFormattingAccelerators(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"DisabledFormattingAccelerators"))
        {
            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::Microsoft::UI::Xaml::Controls::DisabledFormattingAccelerators>(arg);

            self->obj.DisabledFormattingAccelerators(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_DesiredCandidateWindowAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"DesiredCandidateWindowAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DesiredCandidateWindowAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_DesiredCandidateWindowAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"DesiredCandidateWindowAlignment"))
        {
            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::Microsoft::UI::Xaml::Controls::CandidateWindowAlignment>(arg);

            self->obj.DesiredCandidateWindowAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_Description(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"Description"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Description());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_Description(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"Description"))
        {
            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.Description(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_ClipboardCopyFormat(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"ClipboardCopyFormat"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ClipboardCopyFormat());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_ClipboardCopyFormat(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"ClipboardCopyFormat"))
        {
            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::Microsoft::UI::Xaml::Controls::RichEditClipboardFormat>(arg);

            self->obj.ClipboardCopyFormat(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_CharacterCasing(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CharacterCasing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CharacterCasing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_CharacterCasing(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CharacterCasing"))
        {
            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::Microsoft::UI::Xaml::Controls::CharacterCasing>(arg);

            self->obj.CharacterCasing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_AcceptsReturn(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"AcceptsReturn"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AcceptsReturn());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBox_put_AcceptsReturn(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"AcceptsReturn"))
        {
            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.AcceptsReturn(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBox_get_Document(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"Document"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Document());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_ProofingMenuFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"ProofingMenuFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ProofingMenuFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_TextDocument(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextDocument"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextDocument());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_AcceptsReturnProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"AcceptsReturnProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::AcceptsReturnProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_CharacterCasingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CharacterCasingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::CharacterCasingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_ClipboardCopyFormatProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"ClipboardCopyFormatProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::ClipboardCopyFormatProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_DescriptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"DescriptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::DescriptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_DesiredCandidateWindowAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"DesiredCandidateWindowAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::DesiredCandidateWindowAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_DisabledFormattingAcceleratorsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"DisabledFormattingAcceleratorsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::DisabledFormattingAcceleratorsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_HorizontalTextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"HorizontalTextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::HorizontalTextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_InputScopeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"InputScopeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::InputScopeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_IsColorFontEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsColorFontEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::IsColorFontEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_IsReadOnlyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsReadOnlyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::IsReadOnlyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_IsSpellCheckEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsSpellCheckEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::IsSpellCheckEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_IsTextPredictionEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"IsTextPredictionEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::IsTextPredictionEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_MaxLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"MaxLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::MaxLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_PlaceholderTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"PlaceholderTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::PlaceholderTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"PreventKeyboardDisplayOnProgrammaticFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::PreventKeyboardDisplayOnProgrammaticFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_ProofingMenuFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"ProofingMenuFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::ProofingMenuFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_SelectionFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::SelectionFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_SelectionHighlightColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionHighlightColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::SelectionHighlightColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_SelectionHighlightColorWhenNotFocusedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionHighlightColorWhenNotFocusedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::SelectionHighlightColorWhenNotFocusedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_TextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::TextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_TextReadingOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextReadingOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::TextReadingOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_get_TextWrappingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextWrappingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichEditBox::TextWrappingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_CandidateWindowBoundsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CandidateWindowBoundsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs>>(arg);

            return py::convert(self->obj.CandidateWindowBoundsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_CandidateWindowBoundsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CandidateWindowBoundsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CandidateWindowBoundsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ContextMenuOpeningEventHandler>(arg);

            return py::convert(self->obj.ContextMenuOpening(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ContextMenuOpening(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_CopyingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CopyingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs>>(arg);

            return py::convert(self->obj.CopyingToClipboard(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_CopyingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CopyingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CopyingToClipboard(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_CuttingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CuttingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs>>(arg);

            return py::convert(self->obj.CuttingToClipboard(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_CuttingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"CuttingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CuttingToClipboard(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_Paste(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"Paste"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::TextControlPasteEventHandler>(arg);

            return py::convert(self->obj.Paste(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_Paste(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"Paste"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Paste(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_SelectionChanging(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs>>(arg);

            return py::convert(self->obj.SelectionChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_SelectionChanging(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"SelectionChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_TextChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.TextChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_TextChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_TextChanging(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs>>(arg);

            return py::convert(self->obj.TextChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_TextChanging(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_TextCompositionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextCompositionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs>>(arg);

            return py::convert(self->obj.TextCompositionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_TextCompositionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextCompositionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextCompositionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_TextCompositionEnded(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextCompositionEnded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs>>(arg);

            return py::convert(self->obj.TextCompositionEnded(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_TextCompositionEnded(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextCompositionEnded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextCompositionEnded(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_add_TextCompositionStarted(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextCompositionStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichEditBox, winrt::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs>>(arg);

            return py::convert(self->obj.TextCompositionStarted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBox_remove_TextCompositionStarted(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichEditBox", L"TextCompositionStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextCompositionStarted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RichEditBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RichEditBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RichEditBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RichEditBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RichEditBox[] = {
        { "get_linguistic_alternatives_async", reinterpret_cast<PyCFunction>(RichEditBox_GetLinguisticAlternativesAsync), METH_VARARGS, nullptr },
        { "add_candidate_window_bounds_changed", reinterpret_cast<PyCFunction>(RichEditBox_add_CandidateWindowBoundsChanged), METH_O, nullptr },
        { "remove_candidate_window_bounds_changed", reinterpret_cast<PyCFunction>(RichEditBox_remove_CandidateWindowBoundsChanged), METH_O, nullptr },
        { "add_context_menu_opening", reinterpret_cast<PyCFunction>(RichEditBox_add_ContextMenuOpening), METH_O, nullptr },
        { "remove_context_menu_opening", reinterpret_cast<PyCFunction>(RichEditBox_remove_ContextMenuOpening), METH_O, nullptr },
        { "add_copying_to_clipboard", reinterpret_cast<PyCFunction>(RichEditBox_add_CopyingToClipboard), METH_O, nullptr },
        { "remove_copying_to_clipboard", reinterpret_cast<PyCFunction>(RichEditBox_remove_CopyingToClipboard), METH_O, nullptr },
        { "add_cutting_to_clipboard", reinterpret_cast<PyCFunction>(RichEditBox_add_CuttingToClipboard), METH_O, nullptr },
        { "remove_cutting_to_clipboard", reinterpret_cast<PyCFunction>(RichEditBox_remove_CuttingToClipboard), METH_O, nullptr },
        { "add_paste", reinterpret_cast<PyCFunction>(RichEditBox_add_Paste), METH_O, nullptr },
        { "remove_paste", reinterpret_cast<PyCFunction>(RichEditBox_remove_Paste), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(RichEditBox_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(RichEditBox_remove_SelectionChanged), METH_O, nullptr },
        { "add_selection_changing", reinterpret_cast<PyCFunction>(RichEditBox_add_SelectionChanging), METH_O, nullptr },
        { "remove_selection_changing", reinterpret_cast<PyCFunction>(RichEditBox_remove_SelectionChanging), METH_O, nullptr },
        { "add_text_changed", reinterpret_cast<PyCFunction>(RichEditBox_add_TextChanged), METH_O, nullptr },
        { "remove_text_changed", reinterpret_cast<PyCFunction>(RichEditBox_remove_TextChanged), METH_O, nullptr },
        { "add_text_changing", reinterpret_cast<PyCFunction>(RichEditBox_add_TextChanging), METH_O, nullptr },
        { "remove_text_changing", reinterpret_cast<PyCFunction>(RichEditBox_remove_TextChanging), METH_O, nullptr },
        { "add_text_composition_changed", reinterpret_cast<PyCFunction>(RichEditBox_add_TextCompositionChanged), METH_O, nullptr },
        { "remove_text_composition_changed", reinterpret_cast<PyCFunction>(RichEditBox_remove_TextCompositionChanged), METH_O, nullptr },
        { "add_text_composition_ended", reinterpret_cast<PyCFunction>(RichEditBox_add_TextCompositionEnded), METH_O, nullptr },
        { "remove_text_composition_ended", reinterpret_cast<PyCFunction>(RichEditBox_remove_TextCompositionEnded), METH_O, nullptr },
        { "add_text_composition_started", reinterpret_cast<PyCFunction>(RichEditBox_add_TextCompositionStarted), METH_O, nullptr },
        { "remove_text_composition_started", reinterpret_cast<PyCFunction>(RichEditBox_remove_TextCompositionStarted), METH_O, nullptr },
        { "_assign_array_", _assign_array_RichEditBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RichEditBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RichEditBox[] = {
        { "text_wrapping", reinterpret_cast<getter>(RichEditBox_get_TextWrapping), reinterpret_cast<setter>(RichEditBox_put_TextWrapping), nullptr, nullptr },
        { "text_reading_order", reinterpret_cast<getter>(RichEditBox_get_TextReadingOrder), reinterpret_cast<setter>(RichEditBox_put_TextReadingOrder), nullptr, nullptr },
        { "text_alignment", reinterpret_cast<getter>(RichEditBox_get_TextAlignment), reinterpret_cast<setter>(RichEditBox_put_TextAlignment), nullptr, nullptr },
        { "selection_highlight_color_when_not_focused", reinterpret_cast<getter>(RichEditBox_get_SelectionHighlightColorWhenNotFocused), reinterpret_cast<setter>(RichEditBox_put_SelectionHighlightColorWhenNotFocused), nullptr, nullptr },
        { "selection_highlight_color", reinterpret_cast<getter>(RichEditBox_get_SelectionHighlightColor), reinterpret_cast<setter>(RichEditBox_put_SelectionHighlightColor), nullptr, nullptr },
        { "selection_flyout", reinterpret_cast<getter>(RichEditBox_get_SelectionFlyout), reinterpret_cast<setter>(RichEditBox_put_SelectionFlyout), nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus", reinterpret_cast<getter>(RichEditBox_get_PreventKeyboardDisplayOnProgrammaticFocus), reinterpret_cast<setter>(RichEditBox_put_PreventKeyboardDisplayOnProgrammaticFocus), nullptr, nullptr },
        { "placeholder_text", reinterpret_cast<getter>(RichEditBox_get_PlaceholderText), reinterpret_cast<setter>(RichEditBox_put_PlaceholderText), nullptr, nullptr },
        { "max_length", reinterpret_cast<getter>(RichEditBox_get_MaxLength), reinterpret_cast<setter>(RichEditBox_put_MaxLength), nullptr, nullptr },
        { "is_text_prediction_enabled", reinterpret_cast<getter>(RichEditBox_get_IsTextPredictionEnabled), reinterpret_cast<setter>(RichEditBox_put_IsTextPredictionEnabled), nullptr, nullptr },
        { "is_spell_check_enabled", reinterpret_cast<getter>(RichEditBox_get_IsSpellCheckEnabled), reinterpret_cast<setter>(RichEditBox_put_IsSpellCheckEnabled), nullptr, nullptr },
        { "is_read_only", reinterpret_cast<getter>(RichEditBox_get_IsReadOnly), reinterpret_cast<setter>(RichEditBox_put_IsReadOnly), nullptr, nullptr },
        { "is_color_font_enabled", reinterpret_cast<getter>(RichEditBox_get_IsColorFontEnabled), reinterpret_cast<setter>(RichEditBox_put_IsColorFontEnabled), nullptr, nullptr },
        { "input_scope", reinterpret_cast<getter>(RichEditBox_get_InputScope), reinterpret_cast<setter>(RichEditBox_put_InputScope), nullptr, nullptr },
        { "horizontal_text_alignment", reinterpret_cast<getter>(RichEditBox_get_HorizontalTextAlignment), reinterpret_cast<setter>(RichEditBox_put_HorizontalTextAlignment), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(RichEditBox_get_HeaderTemplate), reinterpret_cast<setter>(RichEditBox_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(RichEditBox_get_Header), reinterpret_cast<setter>(RichEditBox_put_Header), nullptr, nullptr },
        { "disabled_formatting_accelerators", reinterpret_cast<getter>(RichEditBox_get_DisabledFormattingAccelerators), reinterpret_cast<setter>(RichEditBox_put_DisabledFormattingAccelerators), nullptr, nullptr },
        { "desired_candidate_window_alignment", reinterpret_cast<getter>(RichEditBox_get_DesiredCandidateWindowAlignment), reinterpret_cast<setter>(RichEditBox_put_DesiredCandidateWindowAlignment), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(RichEditBox_get_Description), reinterpret_cast<setter>(RichEditBox_put_Description), nullptr, nullptr },
        { "clipboard_copy_format", reinterpret_cast<getter>(RichEditBox_get_ClipboardCopyFormat), reinterpret_cast<setter>(RichEditBox_put_ClipboardCopyFormat), nullptr, nullptr },
        { "character_casing", reinterpret_cast<getter>(RichEditBox_get_CharacterCasing), reinterpret_cast<setter>(RichEditBox_put_CharacterCasing), nullptr, nullptr },
        { "accepts_return", reinterpret_cast<getter>(RichEditBox_get_AcceptsReturn), reinterpret_cast<setter>(RichEditBox_put_AcceptsReturn), nullptr, nullptr },
        { "document", reinterpret_cast<getter>(RichEditBox_get_Document), nullptr, nullptr, nullptr },
        { "proofing_menu_flyout", reinterpret_cast<getter>(RichEditBox_get_ProofingMenuFlyout), nullptr, nullptr, nullptr },
        { "text_document", reinterpret_cast<getter>(RichEditBox_get_TextDocument), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RichEditBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RichEditBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RichEditBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RichEditBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RichEditBox) },
        { },
    };

    static PyType_Spec type_spec_RichEditBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichEditBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RichEditBox
    };

    static PyGetSetDef getset_RichEditBox_Static[] = {
        { "accepts_return_property", reinterpret_cast<getter>(RichEditBox_get_AcceptsReturnProperty), nullptr, nullptr, nullptr },
        { "character_casing_property", reinterpret_cast<getter>(RichEditBox_get_CharacterCasingProperty), nullptr, nullptr, nullptr },
        { "clipboard_copy_format_property", reinterpret_cast<getter>(RichEditBox_get_ClipboardCopyFormatProperty), nullptr, nullptr, nullptr },
        { "description_property", reinterpret_cast<getter>(RichEditBox_get_DescriptionProperty), nullptr, nullptr, nullptr },
        { "desired_candidate_window_alignment_property", reinterpret_cast<getter>(RichEditBox_get_DesiredCandidateWindowAlignmentProperty), nullptr, nullptr, nullptr },
        { "disabled_formatting_accelerators_property", reinterpret_cast<getter>(RichEditBox_get_DisabledFormattingAcceleratorsProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(RichEditBox_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(RichEditBox_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "horizontal_text_alignment_property", reinterpret_cast<getter>(RichEditBox_get_HorizontalTextAlignmentProperty), nullptr, nullptr, nullptr },
        { "input_scope_property", reinterpret_cast<getter>(RichEditBox_get_InputScopeProperty), nullptr, nullptr, nullptr },
        { "is_color_font_enabled_property", reinterpret_cast<getter>(RichEditBox_get_IsColorFontEnabledProperty), nullptr, nullptr, nullptr },
        { "is_read_only_property", reinterpret_cast<getter>(RichEditBox_get_IsReadOnlyProperty), nullptr, nullptr, nullptr },
        { "is_spell_check_enabled_property", reinterpret_cast<getter>(RichEditBox_get_IsSpellCheckEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_prediction_enabled_property", reinterpret_cast<getter>(RichEditBox_get_IsTextPredictionEnabledProperty), nullptr, nullptr, nullptr },
        { "max_length_property", reinterpret_cast<getter>(RichEditBox_get_MaxLengthProperty), nullptr, nullptr, nullptr },
        { "placeholder_text_property", reinterpret_cast<getter>(RichEditBox_get_PlaceholderTextProperty), nullptr, nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus_property", reinterpret_cast<getter>(RichEditBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty), nullptr, nullptr, nullptr },
        { "proofing_menu_flyout_property", reinterpret_cast<getter>(RichEditBox_get_ProofingMenuFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_flyout_property", reinterpret_cast<getter>(RichEditBox_get_SelectionFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_property", reinterpret_cast<getter>(RichEditBox_get_SelectionHighlightColorProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_when_not_focused_property", reinterpret_cast<getter>(RichEditBox_get_SelectionHighlightColorWhenNotFocusedProperty), nullptr, nullptr, nullptr },
        { "text_alignment_property", reinterpret_cast<getter>(RichEditBox_get_TextAlignmentProperty), nullptr, nullptr, nullptr },
        { "text_reading_order_property", reinterpret_cast<getter>(RichEditBox_get_TextReadingOrderProperty), nullptr, nullptr, nullptr },
        { "text_wrapping_property", reinterpret_cast<getter>(RichEditBox_get_TextWrappingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RichEditBox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RichEditBox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RichEditBox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RichEditBox_Static) },
        { }
    };

    static PyType_Spec type_spec_RichEditBox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichEditBox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RichEditBox_Static
    };

    // ----- RichEditBoxSelectionChangingEventArgs class --------------------

    static PyObject* _new_RichEditBoxSelectionChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_RichEditBoxSelectionChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RichEditBoxSelectionChangingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichEditBoxSelectionChangingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichEditBoxSelectionChangingEventArgs_get_SelectionLength(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs", L"SelectionLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichEditBoxSelectionChangingEventArgs_get_SelectionStart(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs", L"SelectionStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RichEditBoxSelectionChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RichEditBoxSelectionChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RichEditBoxSelectionChangingEventArgs[] = {
        { "_assign_array_", _assign_array_RichEditBoxSelectionChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RichEditBoxSelectionChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RichEditBoxSelectionChangingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(RichEditBoxSelectionChangingEventArgs_get_Cancel), reinterpret_cast<setter>(RichEditBoxSelectionChangingEventArgs_put_Cancel), nullptr, nullptr },
        { "selection_length", reinterpret_cast<getter>(RichEditBoxSelectionChangingEventArgs_get_SelectionLength), nullptr, nullptr, nullptr },
        { "selection_start", reinterpret_cast<getter>(RichEditBoxSelectionChangingEventArgs_get_SelectionStart), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RichEditBoxSelectionChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RichEditBoxSelectionChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RichEditBoxSelectionChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RichEditBoxSelectionChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RichEditBoxSelectionChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_RichEditBoxSelectionChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichEditBoxSelectionChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxSelectionChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RichEditBoxSelectionChangingEventArgs
    };

    // ----- RichEditBoxTextChangingEventArgs class --------------------

    static PyObject* _new_RichEditBoxTextChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_RichEditBoxTextChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RichEditBoxTextChangingEventArgs_get_IsContentChanging(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs", L"IsContentChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsContentChanging());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RichEditBoxTextChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RichEditBoxTextChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RichEditBoxTextChangingEventArgs[] = {
        { "_assign_array_", _assign_array_RichEditBoxTextChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RichEditBoxTextChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RichEditBoxTextChangingEventArgs[] = {
        { "is_content_changing", reinterpret_cast<getter>(RichEditBoxTextChangingEventArgs_get_IsContentChanging), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RichEditBoxTextChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RichEditBoxTextChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RichEditBoxTextChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RichEditBoxTextChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RichEditBoxTextChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_RichEditBoxTextChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichEditBoxTextChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RichEditBoxTextChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RichEditBoxTextChangingEventArgs
    };

    // ----- RichTextBlock class --------------------

    static PyObject* _new_RichTextBlock(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::Microsoft::UI::Xaml::Controls::RichTextBlock 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_RichTextBlock(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RichTextBlock_CopySelectionToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"CopySelectionToClipboard", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CopySelectionToClipboard();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_GetPositionFromPoint(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"GetPositionFromPoint", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Point>(args, 0);

                return py::convert(self->obj.GetPositionFromPoint(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_Select(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"Select", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Documents::TextPointer>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Documents::TextPointer>(args, 1);

                self->obj.Select(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"HorizontalTextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalTextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"HorizontalTextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.HorizontalTextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"LineHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LineHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"LineHeight"))
        {
            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<double>(arg);

            self->obj.LineHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"Foreground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Foreground());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"Foreground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Foreground(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontWeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

            self->obj.FontWeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

            self->obj.FontStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontStretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontStretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontStretch"))
        {
            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::UI::Text::FontStretch>(arg);

            self->obj.FontStretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontSize"))
        {
            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<double>(arg);

            self->obj.FontSize(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontFamily());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

            self->obj.FontFamily(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_IsTextSelectionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextSelectionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextSelectionEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_IsTextSelectionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextSelectionEnabled"))
        {
            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.IsTextSelectionEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextScaleFactorEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextScaleFactorEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextScaleFactorEnabled"))
        {
            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.IsTextScaleFactorEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"CharacterSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CharacterSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"CharacterSpacing"))
        {
            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<int32_t>(arg);

            self->obj.CharacterSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsColorFontEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsColorFontEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsColorFontEnabled"))
        {
            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.IsColorFontEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextWrapping"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextWrapping());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextWrapping"))
        {
            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::Microsoft::UI::Xaml::TextWrapping>(arg);

            self->obj.TextWrapping(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_LineStackingStrategy(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"LineStackingStrategy"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LineStackingStrategy());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_LineStackingStrategy(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"LineStackingStrategy"))
        {
            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::Microsoft::UI::Xaml::LineStackingStrategy>(arg);

            self->obj.LineStackingStrategy(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_TextTrimming(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextTrimming"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextTrimming());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_TextTrimming(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextTrimming"))
        {
            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::Microsoft::UI::Xaml::TextTrimming>(arg);

            self->obj.TextTrimming(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextReadingOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextReadingOrder());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextReadingOrder"))
        {
            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::Microsoft::UI::Xaml::TextReadingOrder>(arg);

            self->obj.TextReadingOrder(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_TextLineBounds(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextLineBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextLineBounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_TextLineBounds(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextLineBounds"))
        {
            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::Microsoft::UI::Xaml::TextLineBounds>(arg);

            self->obj.TextLineBounds(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_TextIndent(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextIndent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextIndent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_TextIndent(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextIndent"))
        {
            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<double>(arg);

            self->obj.TextIndent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_TextDecorations(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextDecorations"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextDecorations());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_TextDecorations(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextDecorations"))
        {
            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::UI::Text::TextDecorations>(arg);

            self->obj.TextDecorations(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.TextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionHighlightColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionHighlightColor"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionFlyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

            self->obj.SelectionFlyout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Padding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.Padding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_OverflowContentTarget(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"OverflowContentTarget"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OverflowContentTarget());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_OverflowContentTarget(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"OverflowContentTarget"))
        {
            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::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow>(arg);

            self->obj.OverflowContentTarget(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_OpticalMarginAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"OpticalMarginAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OpticalMarginAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_OpticalMarginAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"OpticalMarginAlignment"))
        {
            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::Microsoft::UI::Xaml::OpticalMarginAlignment>(arg);

            self->obj.OpticalMarginAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"MaxLines"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxLines());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlock_put_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"MaxLines"))
        {
            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<int32_t>(arg);

            self->obj.MaxLines(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlock_get_Blocks(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"Blocks"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Blocks());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_ContentEnd(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"ContentEnd"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentEnd());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_ContentStart(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"ContentStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_HasOverflowContent(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"HasOverflowContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasOverflowContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_IsTextTrimmed(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextTrimmed"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextTrimmed());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_SelectedText(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectedText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_SelectionEnd(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionEnd"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionEnd());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_SelectionStart(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextHighlighters(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextHighlighters"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextHighlighters());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_BaselineOffset(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"BaselineOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BaselineOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_CharacterSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"CharacterSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::CharacterSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_FontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::FontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_FontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::FontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_FontStretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontStretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::FontStretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_FontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::FontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_FontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"FontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::FontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_ForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"ForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::ForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_HasOverflowContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"HasOverflowContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::HasOverflowContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_HorizontalTextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"HorizontalTextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::HorizontalTextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_IsColorFontEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsColorFontEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::IsColorFontEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_IsTextScaleFactorEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextScaleFactorEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::IsTextScaleFactorEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_IsTextSelectionEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextSelectionEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::IsTextSelectionEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_IsTextTrimmedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextTrimmedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::IsTextTrimmedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_LineHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"LineHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::LineHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_LineStackingStrategyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"LineStackingStrategyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::LineStackingStrategyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_MaxLinesProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"MaxLinesProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::MaxLinesProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_OpticalMarginAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"OpticalMarginAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::OpticalMarginAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_OverflowContentTargetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"OverflowContentTargetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::OverflowContentTargetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_SelectedTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectedTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::SelectedTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_SelectionFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::SelectionFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_SelectionHighlightColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionHighlightColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::SelectionHighlightColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::TextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextDecorationsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextDecorationsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::TextDecorationsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextIndentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextIndentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::TextIndentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextLineBoundsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextLineBoundsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::TextLineBoundsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextReadingOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextReadingOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::TextReadingOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextTrimmingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextTrimmingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::TextTrimmingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_get_TextWrappingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"TextWrappingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlock::TextWrappingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_add_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ContextMenuOpeningEventHandler>(arg);

            return py::convert(self->obj.ContextMenuOpening(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_remove_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ContextMenuOpening(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_add_IsTextTrimmedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextTrimmedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichTextBlock, winrt::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs>>(arg);

            return py::convert(self->obj.IsTextTrimmedChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_remove_IsTextTrimmedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"IsTextTrimmedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.IsTextTrimmedChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlock_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlock", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RichTextBlock(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RichTextBlock>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RichTextBlock(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RichTextBlock>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RichTextBlock[] = {
        { "copy_selection_to_clipboard", reinterpret_cast<PyCFunction>(RichTextBlock_CopySelectionToClipboard), METH_VARARGS, nullptr },
        { "get_position_from_point", reinterpret_cast<PyCFunction>(RichTextBlock_GetPositionFromPoint), METH_VARARGS, nullptr },
        { "select", reinterpret_cast<PyCFunction>(RichTextBlock_Select), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(RichTextBlock_SelectAll), METH_VARARGS, nullptr },
        { "add_context_menu_opening", reinterpret_cast<PyCFunction>(RichTextBlock_add_ContextMenuOpening), METH_O, nullptr },
        { "remove_context_menu_opening", reinterpret_cast<PyCFunction>(RichTextBlock_remove_ContextMenuOpening), METH_O, nullptr },
        { "add_is_text_trimmed_changed", reinterpret_cast<PyCFunction>(RichTextBlock_add_IsTextTrimmedChanged), METH_O, nullptr },
        { "remove_is_text_trimmed_changed", reinterpret_cast<PyCFunction>(RichTextBlock_remove_IsTextTrimmedChanged), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(RichTextBlock_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(RichTextBlock_remove_SelectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_RichTextBlock, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RichTextBlock), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RichTextBlock[] = {
        { "horizontal_text_alignment", reinterpret_cast<getter>(RichTextBlock_get_HorizontalTextAlignment), reinterpret_cast<setter>(RichTextBlock_put_HorizontalTextAlignment), nullptr, nullptr },
        { "line_height", reinterpret_cast<getter>(RichTextBlock_get_LineHeight), reinterpret_cast<setter>(RichTextBlock_put_LineHeight), nullptr, nullptr },
        { "foreground", reinterpret_cast<getter>(RichTextBlock_get_Foreground), reinterpret_cast<setter>(RichTextBlock_put_Foreground), nullptr, nullptr },
        { "font_weight", reinterpret_cast<getter>(RichTextBlock_get_FontWeight), reinterpret_cast<setter>(RichTextBlock_put_FontWeight), nullptr, nullptr },
        { "font_style", reinterpret_cast<getter>(RichTextBlock_get_FontStyle), reinterpret_cast<setter>(RichTextBlock_put_FontStyle), nullptr, nullptr },
        { "font_stretch", reinterpret_cast<getter>(RichTextBlock_get_FontStretch), reinterpret_cast<setter>(RichTextBlock_put_FontStretch), nullptr, nullptr },
        { "font_size", reinterpret_cast<getter>(RichTextBlock_get_FontSize), reinterpret_cast<setter>(RichTextBlock_put_FontSize), nullptr, nullptr },
        { "font_family", reinterpret_cast<getter>(RichTextBlock_get_FontFamily), reinterpret_cast<setter>(RichTextBlock_put_FontFamily), nullptr, nullptr },
        { "is_text_selection_enabled", reinterpret_cast<getter>(RichTextBlock_get_IsTextSelectionEnabled), reinterpret_cast<setter>(RichTextBlock_put_IsTextSelectionEnabled), nullptr, nullptr },
        { "is_text_scale_factor_enabled", reinterpret_cast<getter>(RichTextBlock_get_IsTextScaleFactorEnabled), reinterpret_cast<setter>(RichTextBlock_put_IsTextScaleFactorEnabled), nullptr, nullptr },
        { "character_spacing", reinterpret_cast<getter>(RichTextBlock_get_CharacterSpacing), reinterpret_cast<setter>(RichTextBlock_put_CharacterSpacing), nullptr, nullptr },
        { "is_color_font_enabled", reinterpret_cast<getter>(RichTextBlock_get_IsColorFontEnabled), reinterpret_cast<setter>(RichTextBlock_put_IsColorFontEnabled), nullptr, nullptr },
        { "text_wrapping", reinterpret_cast<getter>(RichTextBlock_get_TextWrapping), reinterpret_cast<setter>(RichTextBlock_put_TextWrapping), nullptr, nullptr },
        { "line_stacking_strategy", reinterpret_cast<getter>(RichTextBlock_get_LineStackingStrategy), reinterpret_cast<setter>(RichTextBlock_put_LineStackingStrategy), nullptr, nullptr },
        { "text_trimming", reinterpret_cast<getter>(RichTextBlock_get_TextTrimming), reinterpret_cast<setter>(RichTextBlock_put_TextTrimming), nullptr, nullptr },
        { "text_reading_order", reinterpret_cast<getter>(RichTextBlock_get_TextReadingOrder), reinterpret_cast<setter>(RichTextBlock_put_TextReadingOrder), nullptr, nullptr },
        { "text_line_bounds", reinterpret_cast<getter>(RichTextBlock_get_TextLineBounds), reinterpret_cast<setter>(RichTextBlock_put_TextLineBounds), nullptr, nullptr },
        { "text_indent", reinterpret_cast<getter>(RichTextBlock_get_TextIndent), reinterpret_cast<setter>(RichTextBlock_put_TextIndent), nullptr, nullptr },
        { "text_decorations", reinterpret_cast<getter>(RichTextBlock_get_TextDecorations), reinterpret_cast<setter>(RichTextBlock_put_TextDecorations), nullptr, nullptr },
        { "text_alignment", reinterpret_cast<getter>(RichTextBlock_get_TextAlignment), reinterpret_cast<setter>(RichTextBlock_put_TextAlignment), nullptr, nullptr },
        { "selection_highlight_color", reinterpret_cast<getter>(RichTextBlock_get_SelectionHighlightColor), reinterpret_cast<setter>(RichTextBlock_put_SelectionHighlightColor), nullptr, nullptr },
        { "selection_flyout", reinterpret_cast<getter>(RichTextBlock_get_SelectionFlyout), reinterpret_cast<setter>(RichTextBlock_put_SelectionFlyout), nullptr, nullptr },
        { "padding", reinterpret_cast<getter>(RichTextBlock_get_Padding), reinterpret_cast<setter>(RichTextBlock_put_Padding), nullptr, nullptr },
        { "overflow_content_target", reinterpret_cast<getter>(RichTextBlock_get_OverflowContentTarget), reinterpret_cast<setter>(RichTextBlock_put_OverflowContentTarget), nullptr, nullptr },
        { "optical_margin_alignment", reinterpret_cast<getter>(RichTextBlock_get_OpticalMarginAlignment), reinterpret_cast<setter>(RichTextBlock_put_OpticalMarginAlignment), nullptr, nullptr },
        { "max_lines", reinterpret_cast<getter>(RichTextBlock_get_MaxLines), reinterpret_cast<setter>(RichTextBlock_put_MaxLines), nullptr, nullptr },
        { "blocks", reinterpret_cast<getter>(RichTextBlock_get_Blocks), nullptr, nullptr, nullptr },
        { "content_end", reinterpret_cast<getter>(RichTextBlock_get_ContentEnd), nullptr, nullptr, nullptr },
        { "content_start", reinterpret_cast<getter>(RichTextBlock_get_ContentStart), nullptr, nullptr, nullptr },
        { "has_overflow_content", reinterpret_cast<getter>(RichTextBlock_get_HasOverflowContent), nullptr, nullptr, nullptr },
        { "is_text_trimmed", reinterpret_cast<getter>(RichTextBlock_get_IsTextTrimmed), nullptr, nullptr, nullptr },
        { "selected_text", reinterpret_cast<getter>(RichTextBlock_get_SelectedText), nullptr, nullptr, nullptr },
        { "selection_end", reinterpret_cast<getter>(RichTextBlock_get_SelectionEnd), nullptr, nullptr, nullptr },
        { "selection_start", reinterpret_cast<getter>(RichTextBlock_get_SelectionStart), nullptr, nullptr, nullptr },
        { "text_highlighters", reinterpret_cast<getter>(RichTextBlock_get_TextHighlighters), nullptr, nullptr, nullptr },
        { "baseline_offset", reinterpret_cast<getter>(RichTextBlock_get_BaselineOffset), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RichTextBlock[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RichTextBlock) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RichTextBlock) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RichTextBlock) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RichTextBlock) },
        { },
    };

    static PyType_Spec type_spec_RichTextBlock =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichTextBlock",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlock),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RichTextBlock
    };

    static PyGetSetDef getset_RichTextBlock_Static[] = {
        { "character_spacing_property", reinterpret_cast<getter>(RichTextBlock_get_CharacterSpacingProperty), nullptr, nullptr, nullptr },
        { "font_family_property", reinterpret_cast<getter>(RichTextBlock_get_FontFamilyProperty), nullptr, nullptr, nullptr },
        { "font_size_property", reinterpret_cast<getter>(RichTextBlock_get_FontSizeProperty), nullptr, nullptr, nullptr },
        { "font_stretch_property", reinterpret_cast<getter>(RichTextBlock_get_FontStretchProperty), nullptr, nullptr, nullptr },
        { "font_style_property", reinterpret_cast<getter>(RichTextBlock_get_FontStyleProperty), nullptr, nullptr, nullptr },
        { "font_weight_property", reinterpret_cast<getter>(RichTextBlock_get_FontWeightProperty), nullptr, nullptr, nullptr },
        { "foreground_property", reinterpret_cast<getter>(RichTextBlock_get_ForegroundProperty), nullptr, nullptr, nullptr },
        { "has_overflow_content_property", reinterpret_cast<getter>(RichTextBlock_get_HasOverflowContentProperty), nullptr, nullptr, nullptr },
        { "horizontal_text_alignment_property", reinterpret_cast<getter>(RichTextBlock_get_HorizontalTextAlignmentProperty), nullptr, nullptr, nullptr },
        { "is_color_font_enabled_property", reinterpret_cast<getter>(RichTextBlock_get_IsColorFontEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_scale_factor_enabled_property", reinterpret_cast<getter>(RichTextBlock_get_IsTextScaleFactorEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_selection_enabled_property", reinterpret_cast<getter>(RichTextBlock_get_IsTextSelectionEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_trimmed_property", reinterpret_cast<getter>(RichTextBlock_get_IsTextTrimmedProperty), nullptr, nullptr, nullptr },
        { "line_height_property", reinterpret_cast<getter>(RichTextBlock_get_LineHeightProperty), nullptr, nullptr, nullptr },
        { "line_stacking_strategy_property", reinterpret_cast<getter>(RichTextBlock_get_LineStackingStrategyProperty), nullptr, nullptr, nullptr },
        { "max_lines_property", reinterpret_cast<getter>(RichTextBlock_get_MaxLinesProperty), nullptr, nullptr, nullptr },
        { "optical_margin_alignment_property", reinterpret_cast<getter>(RichTextBlock_get_OpticalMarginAlignmentProperty), nullptr, nullptr, nullptr },
        { "overflow_content_target_property", reinterpret_cast<getter>(RichTextBlock_get_OverflowContentTargetProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(RichTextBlock_get_PaddingProperty), nullptr, nullptr, nullptr },
        { "selected_text_property", reinterpret_cast<getter>(RichTextBlock_get_SelectedTextProperty), nullptr, nullptr, nullptr },
        { "selection_flyout_property", reinterpret_cast<getter>(RichTextBlock_get_SelectionFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_property", reinterpret_cast<getter>(RichTextBlock_get_SelectionHighlightColorProperty), nullptr, nullptr, nullptr },
        { "text_alignment_property", reinterpret_cast<getter>(RichTextBlock_get_TextAlignmentProperty), nullptr, nullptr, nullptr },
        { "text_decorations_property", reinterpret_cast<getter>(RichTextBlock_get_TextDecorationsProperty), nullptr, nullptr, nullptr },
        { "text_indent_property", reinterpret_cast<getter>(RichTextBlock_get_TextIndentProperty), nullptr, nullptr, nullptr },
        { "text_line_bounds_property", reinterpret_cast<getter>(RichTextBlock_get_TextLineBoundsProperty), nullptr, nullptr, nullptr },
        { "text_reading_order_property", reinterpret_cast<getter>(RichTextBlock_get_TextReadingOrderProperty), nullptr, nullptr, nullptr },
        { "text_trimming_property", reinterpret_cast<getter>(RichTextBlock_get_TextTrimmingProperty), nullptr, nullptr, nullptr },
        { "text_wrapping_property", reinterpret_cast<getter>(RichTextBlock_get_TextWrappingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RichTextBlock_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RichTextBlock_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RichTextBlock_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RichTextBlock_Static) },
        { }
    };

    static PyType_Spec type_spec_RichTextBlock_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichTextBlock_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RichTextBlock_Static
    };

    // ----- RichTextBlockOverflow class --------------------

    static PyObject* _new_RichTextBlockOverflow(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::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow 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_RichTextBlockOverflow(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RichTextBlockOverflow_GetPositionFromPoint(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"GetPositionFromPoint", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Point>(args, 0);

                return py::convert(self->obj.GetPositionFromPoint(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Padding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlockOverflow_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.Padding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlockOverflow_get_OverflowContentTarget(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"OverflowContentTarget"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OverflowContentTarget());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlockOverflow_put_OverflowContentTarget(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"OverflowContentTarget"))
        {
            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::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow>(arg);

            self->obj.OverflowContentTarget(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlockOverflow_get_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"MaxLines"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxLines());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RichTextBlockOverflow_put_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"MaxLines"))
        {
            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<int32_t>(arg);

            self->obj.MaxLines(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RichTextBlockOverflow_get_BaselineOffset(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"BaselineOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BaselineOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_ContentEnd(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"ContentEnd"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentEnd());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_ContentSource(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"ContentSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_ContentStart(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"ContentStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_HasOverflowContent(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"HasOverflowContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasOverflowContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_IsTextTrimmed(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"IsTextTrimmed"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextTrimmed());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_HasOverflowContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"HasOverflowContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow::HasOverflowContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_IsTextTrimmedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"IsTextTrimmedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow::IsTextTrimmedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_MaxLinesProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"MaxLinesProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow::MaxLinesProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_OverflowContentTargetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"OverflowContentTargetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow::OverflowContentTargetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_add_IsTextTrimmedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"IsTextTrimmedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow, winrt::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs>>(arg);

            return py::convert(self->obj.IsTextTrimmedChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RichTextBlockOverflow_remove_IsTextTrimmedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.RichTextBlockOverflow", L"IsTextTrimmedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.IsTextTrimmedChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RichTextBlockOverflow(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RichTextBlockOverflow(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RichTextBlockOverflow[] = {
        { "get_position_from_point", reinterpret_cast<PyCFunction>(RichTextBlockOverflow_GetPositionFromPoint), METH_VARARGS, nullptr },
        { "add_is_text_trimmed_changed", reinterpret_cast<PyCFunction>(RichTextBlockOverflow_add_IsTextTrimmedChanged), METH_O, nullptr },
        { "remove_is_text_trimmed_changed", reinterpret_cast<PyCFunction>(RichTextBlockOverflow_remove_IsTextTrimmedChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_RichTextBlockOverflow, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RichTextBlockOverflow), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RichTextBlockOverflow[] = {
        { "padding", reinterpret_cast<getter>(RichTextBlockOverflow_get_Padding), reinterpret_cast<setter>(RichTextBlockOverflow_put_Padding), nullptr, nullptr },
        { "overflow_content_target", reinterpret_cast<getter>(RichTextBlockOverflow_get_OverflowContentTarget), reinterpret_cast<setter>(RichTextBlockOverflow_put_OverflowContentTarget), nullptr, nullptr },
        { "max_lines", reinterpret_cast<getter>(RichTextBlockOverflow_get_MaxLines), reinterpret_cast<setter>(RichTextBlockOverflow_put_MaxLines), nullptr, nullptr },
        { "baseline_offset", reinterpret_cast<getter>(RichTextBlockOverflow_get_BaselineOffset), nullptr, nullptr, nullptr },
        { "content_end", reinterpret_cast<getter>(RichTextBlockOverflow_get_ContentEnd), nullptr, nullptr, nullptr },
        { "content_source", reinterpret_cast<getter>(RichTextBlockOverflow_get_ContentSource), nullptr, nullptr, nullptr },
        { "content_start", reinterpret_cast<getter>(RichTextBlockOverflow_get_ContentStart), nullptr, nullptr, nullptr },
        { "has_overflow_content", reinterpret_cast<getter>(RichTextBlockOverflow_get_HasOverflowContent), nullptr, nullptr, nullptr },
        { "is_text_trimmed", reinterpret_cast<getter>(RichTextBlockOverflow_get_IsTextTrimmed), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RichTextBlockOverflow[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RichTextBlockOverflow) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RichTextBlockOverflow) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RichTextBlockOverflow) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RichTextBlockOverflow) },
        { },
    };

    static PyType_Spec type_spec_RichTextBlockOverflow =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichTextBlockOverflow",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RichTextBlockOverflow),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RichTextBlockOverflow
    };

    static PyGetSetDef getset_RichTextBlockOverflow_Static[] = {
        { "has_overflow_content_property", reinterpret_cast<getter>(RichTextBlockOverflow_get_HasOverflowContentProperty), nullptr, nullptr, nullptr },
        { "is_text_trimmed_property", reinterpret_cast<getter>(RichTextBlockOverflow_get_IsTextTrimmedProperty), nullptr, nullptr, nullptr },
        { "max_lines_property", reinterpret_cast<getter>(RichTextBlockOverflow_get_MaxLinesProperty), nullptr, nullptr, nullptr },
        { "overflow_content_target_property", reinterpret_cast<getter>(RichTextBlockOverflow_get_OverflowContentTargetProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(RichTextBlockOverflow_get_PaddingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RichTextBlockOverflow_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RichTextBlockOverflow_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RichTextBlockOverflow_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RichTextBlockOverflow_Static) },
        { }
    };

    static PyType_Spec type_spec_RichTextBlockOverflow_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RichTextBlockOverflow_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RichTextBlockOverflow_Static
    };

    // ----- RowDefinition class --------------------

    static PyObject* _new_RowDefinition(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::Microsoft::UI::Xaml::Controls::RowDefinition 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_RowDefinition(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RowDefinition_get_MinHeight(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"MinHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RowDefinition_put_MinHeight(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"MinHeight"))
        {
            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<double>(arg);

            self->obj.MinHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RowDefinition_get_MaxHeight(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"MaxHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RowDefinition_put_MaxHeight(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"MaxHeight"))
        {
            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<double>(arg);

            self->obj.MaxHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RowDefinition_get_Height(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"Height"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Height());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RowDefinition_put_Height(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"Height"))
        {
            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::Microsoft::UI::Xaml::GridLength>(arg);

            self->obj.Height(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* RowDefinition_get_ActualHeight(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"ActualHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActualHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RowDefinition_get_HeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"HeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RowDefinition::HeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RowDefinition_get_MaxHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"MaxHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RowDefinition::MaxHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RowDefinition_get_MinHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinition", L"MinHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::RowDefinition::MinHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_RowDefinition(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RowDefinition>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RowDefinition(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RowDefinition>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RowDefinition[] = {
        { "_assign_array_", _assign_array_RowDefinition, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RowDefinition), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RowDefinition[] = {
        { "min_height", reinterpret_cast<getter>(RowDefinition_get_MinHeight), reinterpret_cast<setter>(RowDefinition_put_MinHeight), nullptr, nullptr },
        { "max_height", reinterpret_cast<getter>(RowDefinition_get_MaxHeight), reinterpret_cast<setter>(RowDefinition_put_MaxHeight), nullptr, nullptr },
        { "height", reinterpret_cast<getter>(RowDefinition_get_Height), reinterpret_cast<setter>(RowDefinition_put_Height), nullptr, nullptr },
        { "actual_height", reinterpret_cast<getter>(RowDefinition_get_ActualHeight), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RowDefinition[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RowDefinition) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RowDefinition) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RowDefinition) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RowDefinition) },
        { },
    };

    static PyType_Spec type_spec_RowDefinition =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RowDefinition",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinition),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RowDefinition
    };

    static PyGetSetDef getset_RowDefinition_Static[] = {
        { "height_property", reinterpret_cast<getter>(RowDefinition_get_HeightProperty), nullptr, nullptr, nullptr },
        { "max_height_property", reinterpret_cast<getter>(RowDefinition_get_MaxHeightProperty), nullptr, nullptr, nullptr },
        { "min_height_property", reinterpret_cast<getter>(RowDefinition_get_MinHeightProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_RowDefinition_Static[] = {
        { }
    };

    static PyType_Slot type_slots_RowDefinition_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_RowDefinition_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_RowDefinition_Static) },
        { }
    };

    static PyType_Spec type_spec_RowDefinition_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RowDefinition_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_RowDefinition_Static
    };

    // ----- RowDefinitionCollection class --------------------

    static PyObject* _new_RowDefinitionCollection(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RowDefinitionCollection>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::RowDefinitionCollection>::type_name);
        return nullptr;
    }

    static void _dealloc_RowDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* RowDefinitionCollection_Append(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"Append", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::RowDefinition>(args, 0);

                self->obj.Append(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_Clear(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"Clear", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Clear();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_First(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", 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* RowDefinitionCollection_GetAt(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", 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* RowDefinitionCollection_GetMany(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", 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::Microsoft::UI::Xaml::Controls::RowDefinition, 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* RowDefinitionCollection_GetView(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"GetView", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetView());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_IndexOf(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::RowDefinition>(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* RowDefinitionCollection_InsertAt(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"InsertAt", 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::Microsoft::UI::Xaml::Controls::RowDefinition>(args, 1);

                self->obj.InsertAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_RemoveAt(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"RemoveAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);

                self->obj.RemoveAt(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_RemoveAtEnd(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"RemoveAtEnd", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RemoveAtEnd();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_ReplaceAll(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"ReplaceAll", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<winrt::Microsoft::UI::Xaml::Controls::RowDefinition, false>>(args, 0);

                self->obj.ReplaceAll(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_SetAt(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", L"SetAt", 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::Microsoft::UI::Xaml::Controls::RowDefinition>(args, 1);

                self->obj.SetAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RowDefinitionCollection_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.RowDefinitionCollection", 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_RowDefinitionCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::RowDefinitionCollection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_RowDefinitionCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::RowDefinitionCollection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_RowDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_RowDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_RowDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* 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_RowDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* 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_RowDefinitionCollection(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::Microsoft::UI::Xaml::Controls::RowDefinition> items(static_cast<uint32_t>(length), empty_instance<winrt::Microsoft::UI::Xaml::Controls::RowDefinition>::get());

            auto count = self->obj.GetMany(static_cast<uint32_t>(start), items);

            if (count != static_cast<uint32_t>(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 int _seq_assign_RowDefinitionCollection(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection* self, Py_ssize_t i, PyObject* value) noexcept
    {
        try
        {
            if (value == nullptr) { self->obj.RemoveAt(static_cast<uint32_t>(i)); }
            else { self->obj.SetAt(static_cast<uint32_t>(i), py::convert_to<winrt::Microsoft::UI::Xaml::Controls::RowDefinition>(value)); }
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyMethodDef _methods_RowDefinitionCollection[] = {
        { "append", reinterpret_cast<PyCFunction>(RowDefinitionCollection_Append), METH_VARARGS, nullptr },
        { "clear", reinterpret_cast<PyCFunction>(RowDefinitionCollection_Clear), METH_VARARGS, nullptr },
        { "first", reinterpret_cast<PyCFunction>(RowDefinitionCollection_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(RowDefinitionCollection_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(RowDefinitionCollection_GetMany), METH_VARARGS, nullptr },
        { "get_view", reinterpret_cast<PyCFunction>(RowDefinitionCollection_GetView), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(RowDefinitionCollection_IndexOf), METH_VARARGS, nullptr },
        { "insert_at", reinterpret_cast<PyCFunction>(RowDefinitionCollection_InsertAt), METH_VARARGS, nullptr },
        { "remove_at", reinterpret_cast<PyCFunction>(RowDefinitionCollection_RemoveAt), METH_VARARGS, nullptr },
        { "remove_at_end", reinterpret_cast<PyCFunction>(RowDefinitionCollection_RemoveAtEnd), METH_VARARGS, nullptr },
        { "replace_all", reinterpret_cast<PyCFunction>(RowDefinitionCollection_ReplaceAll), METH_VARARGS, nullptr },
        { "set_at", reinterpret_cast<PyCFunction>(RowDefinitionCollection_SetAt), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_RowDefinitionCollection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RowDefinitionCollection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RowDefinitionCollection[] = {
        { "size", reinterpret_cast<getter>(RowDefinitionCollection_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RowDefinitionCollection[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_RowDefinitionCollection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_RowDefinitionCollection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_RowDefinitionCollection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_RowDefinitionCollection) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_RowDefinitionCollection) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_RowDefinitionCollection) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_RowDefinitionCollection) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_RowDefinitionCollection) },
        { Py_sq_ass_item, reinterpret_cast<void*>(_seq_assign_RowDefinitionCollection) },
        { },
    };

    static PyType_Spec type_spec_RowDefinitionCollection =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.RowDefinitionCollection",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::RowDefinitionCollection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RowDefinitionCollection
    };

    // ----- ScrollContentPresenter class --------------------

    static PyObject* _new_ScrollContentPresenter(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::Microsoft::UI::Xaml::Controls::ScrollContentPresenter 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_ScrollContentPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollContentPresenter_LineDown(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"LineDown", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.LineDown();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_LineLeft(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"LineLeft", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.LineLeft();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_LineRight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"LineRight", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.LineRight();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_LineUp(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"LineUp", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.LineUp();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_MakeVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"MakeVisible", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Rect>(args, 1);

                return py::convert(self->obj.MakeVisible(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_MouseWheelDown(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"MouseWheelDown", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.MouseWheelDown();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_MouseWheelLeft(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"MouseWheelLeft", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.MouseWheelLeft();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_MouseWheelRight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"MouseWheelRight", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.MouseWheelRight();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_MouseWheelUp(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"MouseWheelUp", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.MouseWheelUp();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_PageDown(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"PageDown", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.PageDown();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_PageLeft(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"PageLeft", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.PageLeft();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_PageRight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"PageRight", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.PageRight();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_PageUp(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"PageUp", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.PageUp();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_SetHorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"SetHorizontalOffset", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);

                self->obj.SetHorizontalOffset(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_SetVerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"SetVerticalOffset", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);

                self->obj.SetVerticalOffset(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_SizesContentToTemplatedParent(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"SizesContentToTemplatedParent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SizesContentToTemplatedParent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollContentPresenter_put_SizesContentToTemplatedParent(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"SizesContentToTemplatedParent"))
        {
            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.SizesContentToTemplatedParent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollContentPresenter_get_ScrollOwner(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"ScrollOwner"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollOwner());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollContentPresenter_put_ScrollOwner(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"ScrollOwner"))
        {
            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.ScrollOwner(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollContentPresenter_get_CanVerticallyScroll(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"CanVerticallyScroll"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanVerticallyScroll());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollContentPresenter_put_CanVerticallyScroll(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"CanVerticallyScroll"))
        {
            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.CanVerticallyScroll(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollContentPresenter_get_CanHorizontallyScroll(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"CanHorizontallyScroll"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanHorizontallyScroll());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollContentPresenter_put_CanHorizontallyScroll(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"CanHorizontallyScroll"))
        {
            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.CanHorizontallyScroll(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollContentPresenter_get_CanContentRenderOutsideBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"CanContentRenderOutsideBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanContentRenderOutsideBounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollContentPresenter_put_CanContentRenderOutsideBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"CanContentRenderOutsideBounds"))
        {
            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.CanContentRenderOutsideBounds(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollContentPresenter_get_ExtentHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"ExtentHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExtentHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_ExtentWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"ExtentWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExtentWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_HorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"HorizontalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_VerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"VerticalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_ViewportHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"ViewportHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ViewportHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_ViewportWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"ViewportWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ViewportWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_CanContentRenderOutsideBoundsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"CanContentRenderOutsideBoundsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollContentPresenter::CanContentRenderOutsideBoundsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollContentPresenter_get_SizesContentToTemplatedParentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollContentPresenter", L"SizesContentToTemplatedParentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollContentPresenter::SizesContentToTemplatedParentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollContentPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollContentPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollContentPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollContentPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollContentPresenter[] = {
        { "line_down", reinterpret_cast<PyCFunction>(ScrollContentPresenter_LineDown), METH_VARARGS, nullptr },
        { "line_left", reinterpret_cast<PyCFunction>(ScrollContentPresenter_LineLeft), METH_VARARGS, nullptr },
        { "line_right", reinterpret_cast<PyCFunction>(ScrollContentPresenter_LineRight), METH_VARARGS, nullptr },
        { "line_up", reinterpret_cast<PyCFunction>(ScrollContentPresenter_LineUp), METH_VARARGS, nullptr },
        { "make_visible", reinterpret_cast<PyCFunction>(ScrollContentPresenter_MakeVisible), METH_VARARGS, nullptr },
        { "mouse_wheel_down", reinterpret_cast<PyCFunction>(ScrollContentPresenter_MouseWheelDown), METH_VARARGS, nullptr },
        { "mouse_wheel_left", reinterpret_cast<PyCFunction>(ScrollContentPresenter_MouseWheelLeft), METH_VARARGS, nullptr },
        { "mouse_wheel_right", reinterpret_cast<PyCFunction>(ScrollContentPresenter_MouseWheelRight), METH_VARARGS, nullptr },
        { "mouse_wheel_up", reinterpret_cast<PyCFunction>(ScrollContentPresenter_MouseWheelUp), METH_VARARGS, nullptr },
        { "page_down", reinterpret_cast<PyCFunction>(ScrollContentPresenter_PageDown), METH_VARARGS, nullptr },
        { "page_left", reinterpret_cast<PyCFunction>(ScrollContentPresenter_PageLeft), METH_VARARGS, nullptr },
        { "page_right", reinterpret_cast<PyCFunction>(ScrollContentPresenter_PageRight), METH_VARARGS, nullptr },
        { "page_up", reinterpret_cast<PyCFunction>(ScrollContentPresenter_PageUp), METH_VARARGS, nullptr },
        { "set_horizontal_offset", reinterpret_cast<PyCFunction>(ScrollContentPresenter_SetHorizontalOffset), METH_VARARGS, nullptr },
        { "set_vertical_offset", reinterpret_cast<PyCFunction>(ScrollContentPresenter_SetVerticalOffset), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ScrollContentPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollContentPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollContentPresenter[] = {
        { "sizes_content_to_templated_parent", reinterpret_cast<getter>(ScrollContentPresenter_get_SizesContentToTemplatedParent), reinterpret_cast<setter>(ScrollContentPresenter_put_SizesContentToTemplatedParent), nullptr, nullptr },
        { "scroll_owner", reinterpret_cast<getter>(ScrollContentPresenter_get_ScrollOwner), reinterpret_cast<setter>(ScrollContentPresenter_put_ScrollOwner), nullptr, nullptr },
        { "can_vertically_scroll", reinterpret_cast<getter>(ScrollContentPresenter_get_CanVerticallyScroll), reinterpret_cast<setter>(ScrollContentPresenter_put_CanVerticallyScroll), nullptr, nullptr },
        { "can_horizontally_scroll", reinterpret_cast<getter>(ScrollContentPresenter_get_CanHorizontallyScroll), reinterpret_cast<setter>(ScrollContentPresenter_put_CanHorizontallyScroll), nullptr, nullptr },
        { "can_content_render_outside_bounds", reinterpret_cast<getter>(ScrollContentPresenter_get_CanContentRenderOutsideBounds), reinterpret_cast<setter>(ScrollContentPresenter_put_CanContentRenderOutsideBounds), nullptr, nullptr },
        { "extent_height", reinterpret_cast<getter>(ScrollContentPresenter_get_ExtentHeight), nullptr, nullptr, nullptr },
        { "extent_width", reinterpret_cast<getter>(ScrollContentPresenter_get_ExtentWidth), nullptr, nullptr, nullptr },
        { "horizontal_offset", reinterpret_cast<getter>(ScrollContentPresenter_get_HorizontalOffset), nullptr, nullptr, nullptr },
        { "vertical_offset", reinterpret_cast<getter>(ScrollContentPresenter_get_VerticalOffset), nullptr, nullptr, nullptr },
        { "viewport_height", reinterpret_cast<getter>(ScrollContentPresenter_get_ViewportHeight), nullptr, nullptr, nullptr },
        { "viewport_width", reinterpret_cast<getter>(ScrollContentPresenter_get_ViewportWidth), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollContentPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollContentPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollContentPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollContentPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollContentPresenter) },
        { },
    };

    static PyType_Spec type_spec_ScrollContentPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollContentPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollContentPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollContentPresenter
    };

    static PyGetSetDef getset_ScrollContentPresenter_Static[] = {
        { "can_content_render_outside_bounds_property", reinterpret_cast<getter>(ScrollContentPresenter_get_CanContentRenderOutsideBoundsProperty), nullptr, nullptr, nullptr },
        { "sizes_content_to_templated_parent_property", reinterpret_cast<getter>(ScrollContentPresenter_get_SizesContentToTemplatedParentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ScrollContentPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ScrollContentPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ScrollContentPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ScrollContentPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_ScrollContentPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollContentPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ScrollContentPresenter_Static
    };

    // ----- ScrollView class --------------------

    static PyObject* _new_ScrollView(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::Microsoft::UI::Xaml::Controls::ScrollView 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_ScrollView(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollView_AddScrollVelocity(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"AddScrollVelocity", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Numerics::float2>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<winrt::Windows::Foundation::Numerics::float2>>(args, 1);

                return py::convert(self->obj.AddScrollVelocity(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_AddZoomVelocity(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"AddZoomVelocity", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<float>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<winrt::Windows::Foundation::Numerics::float2>>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::IReference<float>>(args, 2);

                return py::convert(self->obj.AddZoomVelocity(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_RegisterAnchorCandidate(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"RegisterAnchorCandidate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.RegisterAnchorCandidate(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_ScrollBy(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollBy", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);

                return py::convert(self->obj.ScrollBy(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollBy", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);
                auto param2 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions>(args, 2);

                return py::convert(self->obj.ScrollBy(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_ScrollTo(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);

                return py::convert(self->obj.ScrollTo(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollTo", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);
                auto param1 = py::convert_to<double>(args, 1);
                auto param2 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions>(args, 2);

                return py::convert(self->obj.ScrollTo(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_UnregisterAnchorCandidate(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"UnregisterAnchorCandidate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.UnregisterAnchorCandidate(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_ZoomBy(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomBy", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<float>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<winrt::Windows::Foundation::Numerics::float2>>(args, 1);

                return py::convert(self->obj.ZoomBy(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomBy", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<float>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<winrt::Windows::Foundation::Numerics::float2>>(args, 1);
                auto param2 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions>(args, 2);

                return py::convert(self->obj.ZoomBy(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_ZoomTo(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<float>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<winrt::Windows::Foundation::Numerics::float2>>(args, 1);

                return py::convert(self->obj.ZoomTo(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomTo", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<float>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<winrt::Windows::Foundation::Numerics::float2>>(args, 1);
                auto param2 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions>(args, 2);

                return py::convert(self->obj.ZoomTo(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalScrollMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_HorizontalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingScrollMode>(arg);

            self->obj.HorizontalScrollMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollChainMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollChainMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalScrollChainMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_HorizontalScrollChainMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollChainMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingChainMode>(arg);

            self->obj.HorizontalScrollChainMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_HorizontalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollBarVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingScrollBarVisibility>(arg);

            self->obj.HorizontalScrollBarVisibility(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_ContentOrientation(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ContentOrientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentOrientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_ContentOrientation(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ContentOrientation"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingContentOrientation>(arg);

            self->obj.ContentOrientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"Content"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_IgnoredInputKinds(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"IgnoredInputKinds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IgnoredInputKinds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_IgnoredInputKinds(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"IgnoredInputKinds"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingInputKinds>(arg);

            self->obj.IgnoredInputKinds(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_HorizontalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalAnchorRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalAnchorRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_HorizontalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalAnchorRatio"))
        {
            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<double>(arg);

            self->obj.HorizontalAnchorRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollRailMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollRailMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalScrollRailMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_HorizontalScrollRailMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollRailMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingRailMode>(arg);

            self->obj.HorizontalScrollRailMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_ZoomMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_ZoomMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingZoomMode>(arg);

            self->obj.ZoomMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_MaxZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"MaxZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_MaxZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"MaxZoomFactor"))
        {
            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<double>(arg);

            self->obj.MaxZoomFactor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_ZoomChainMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomChainMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomChainMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_ZoomChainMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomChainMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingChainMode>(arg);

            self->obj.ZoomChainMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollRailMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollRailMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalScrollRailMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_VerticalScrollRailMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollRailMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingRailMode>(arg);

            self->obj.VerticalScrollRailMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalScrollMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_VerticalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingScrollMode>(arg);

            self->obj.VerticalScrollMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollChainMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollChainMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalScrollChainMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_VerticalScrollChainMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollChainMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingChainMode>(arg);

            self->obj.VerticalScrollChainMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_VerticalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollBarVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingScrollBarVisibility>(arg);

            self->obj.VerticalScrollBarVisibility(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_VerticalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalAnchorRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalAnchorRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_VerticalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalAnchorRatio"))
        {
            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<double>(arg);

            self->obj.VerticalAnchorRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_MinZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"MinZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollView_put_MinZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"MinZoomFactor"))
        {
            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<double>(arg);

            self->obj.MinZoomFactor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollView_get_ComputedHorizontalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedHorizontalScrollMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ComputedHorizontalScrollMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ComputedVerticalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedVerticalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ComputedVerticalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ComputedVerticalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedVerticalScrollMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ComputedVerticalScrollMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_CurrentAnchor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"CurrentAnchor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CurrentAnchor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ExpressionAnimationSources(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ExpressionAnimationSources"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExpressionAnimationSources());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ExtentHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ExtentHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExtentHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ExtentWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ExtentWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExtentWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_HorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ScrollPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollPresenter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollPresenter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ScrollableHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollableHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollableHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ScrollableWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollableWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollableWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_State(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"State"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.State());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_VerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ViewportHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ViewportHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ViewportHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ViewportWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ViewportWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ViewportWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ComputedHorizontalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedHorizontalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ComputedHorizontalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ComputedHorizontalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedHorizontalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ComputedHorizontalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ComputedHorizontalScrollModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedHorizontalScrollModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ComputedHorizontalScrollModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ComputedVerticalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedVerticalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ComputedVerticalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ComputedVerticalScrollModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ComputedVerticalScrollModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ComputedVerticalScrollModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ContentOrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ContentOrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ContentOrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_HorizontalAnchorRatioProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalAnchorRatioProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::HorizontalAnchorRatioProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::HorizontalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollChainModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollChainModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::HorizontalScrollChainModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::HorizontalScrollModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_HorizontalScrollRailModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"HorizontalScrollRailModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::HorizontalScrollRailModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_IgnoredInputKindsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"IgnoredInputKindsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::IgnoredInputKindsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_MaxZoomFactorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"MaxZoomFactorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::MaxZoomFactorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_MinZoomFactorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"MinZoomFactorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::MinZoomFactorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ScrollPresenterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollPresenterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ScrollPresenterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_VerticalAnchorRatioProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalAnchorRatioProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::VerticalAnchorRatioProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::VerticalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollChainModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollChainModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::VerticalScrollChainModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::VerticalScrollModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_VerticalScrollRailModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"VerticalScrollRailModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::VerticalScrollRailModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ZoomChainModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomChainModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ZoomChainModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_get_ZoomModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollView::ZoomModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_AnchorRequested(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"AnchorRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs>>(arg);

            return py::convert(self->obj.AnchorRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_AnchorRequested(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"AnchorRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.AnchorRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_BringingIntoView(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"BringingIntoView"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs>>(arg);

            return py::convert(self->obj.BringingIntoView(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_BringingIntoView(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"BringingIntoView"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.BringingIntoView(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_ExtentChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ExtentChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ExtentChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_ExtentChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ExtentChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ExtentChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_ScrollAnimationStarting(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollAnimationStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs>>(arg);

            return py::convert(self->obj.ScrollAnimationStarting(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_ScrollAnimationStarting(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollAnimationStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ScrollAnimationStarting(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_ScrollCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs>>(arg);

            return py::convert(self->obj.ScrollCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_ScrollCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ScrollCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ScrollCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_StateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"StateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.StateChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_StateChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"StateChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.StateChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_ViewChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ViewChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ViewChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_ViewChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ViewChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ViewChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_ZoomAnimationStarting(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomAnimationStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs>>(arg);

            return py::convert(self->obj.ZoomAnimationStarting(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_ZoomAnimationStarting(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomAnimationStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ZoomAnimationStarting(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_add_ZoomCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollView, winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs>>(arg);

            return py::convert(self->obj.ZoomCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollView_remove_ZoomCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollView", L"ZoomCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ZoomCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollView[] = {
        { "add_scroll_velocity", reinterpret_cast<PyCFunction>(ScrollView_AddScrollVelocity), METH_VARARGS, nullptr },
        { "add_zoom_velocity", reinterpret_cast<PyCFunction>(ScrollView_AddZoomVelocity), METH_VARARGS, nullptr },
        { "register_anchor_candidate", reinterpret_cast<PyCFunction>(ScrollView_RegisterAnchorCandidate), METH_VARARGS, nullptr },
        { "scroll_by", reinterpret_cast<PyCFunction>(ScrollView_ScrollBy), METH_VARARGS, nullptr },
        { "scroll_to", reinterpret_cast<PyCFunction>(ScrollView_ScrollTo), METH_VARARGS, nullptr },
        { "unregister_anchor_candidate", reinterpret_cast<PyCFunction>(ScrollView_UnregisterAnchorCandidate), METH_VARARGS, nullptr },
        { "zoom_by", reinterpret_cast<PyCFunction>(ScrollView_ZoomBy), METH_VARARGS, nullptr },
        { "zoom_to", reinterpret_cast<PyCFunction>(ScrollView_ZoomTo), METH_VARARGS, nullptr },
        { "add_anchor_requested", reinterpret_cast<PyCFunction>(ScrollView_add_AnchorRequested), METH_O, nullptr },
        { "remove_anchor_requested", reinterpret_cast<PyCFunction>(ScrollView_remove_AnchorRequested), METH_O, nullptr },
        { "add_bringing_into_view", reinterpret_cast<PyCFunction>(ScrollView_add_BringingIntoView), METH_O, nullptr },
        { "remove_bringing_into_view", reinterpret_cast<PyCFunction>(ScrollView_remove_BringingIntoView), METH_O, nullptr },
        { "add_extent_changed", reinterpret_cast<PyCFunction>(ScrollView_add_ExtentChanged), METH_O, nullptr },
        { "remove_extent_changed", reinterpret_cast<PyCFunction>(ScrollView_remove_ExtentChanged), METH_O, nullptr },
        { "add_scroll_animation_starting", reinterpret_cast<PyCFunction>(ScrollView_add_ScrollAnimationStarting), METH_O, nullptr },
        { "remove_scroll_animation_starting", reinterpret_cast<PyCFunction>(ScrollView_remove_ScrollAnimationStarting), METH_O, nullptr },
        { "add_scroll_completed", reinterpret_cast<PyCFunction>(ScrollView_add_ScrollCompleted), METH_O, nullptr },
        { "remove_scroll_completed", reinterpret_cast<PyCFunction>(ScrollView_remove_ScrollCompleted), METH_O, nullptr },
        { "add_state_changed", reinterpret_cast<PyCFunction>(ScrollView_add_StateChanged), METH_O, nullptr },
        { "remove_state_changed", reinterpret_cast<PyCFunction>(ScrollView_remove_StateChanged), METH_O, nullptr },
        { "add_view_changed", reinterpret_cast<PyCFunction>(ScrollView_add_ViewChanged), METH_O, nullptr },
        { "remove_view_changed", reinterpret_cast<PyCFunction>(ScrollView_remove_ViewChanged), METH_O, nullptr },
        { "add_zoom_animation_starting", reinterpret_cast<PyCFunction>(ScrollView_add_ZoomAnimationStarting), METH_O, nullptr },
        { "remove_zoom_animation_starting", reinterpret_cast<PyCFunction>(ScrollView_remove_ZoomAnimationStarting), METH_O, nullptr },
        { "add_zoom_completed", reinterpret_cast<PyCFunction>(ScrollView_add_ZoomCompleted), METH_O, nullptr },
        { "remove_zoom_completed", reinterpret_cast<PyCFunction>(ScrollView_remove_ZoomCompleted), METH_O, nullptr },
        { "_assign_array_", _assign_array_ScrollView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollView[] = {
        { "horizontal_scroll_mode", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollMode), reinterpret_cast<setter>(ScrollView_put_HorizontalScrollMode), nullptr, nullptr },
        { "horizontal_scroll_chain_mode", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollChainMode), reinterpret_cast<setter>(ScrollView_put_HorizontalScrollChainMode), nullptr, nullptr },
        { "horizontal_scroll_bar_visibility", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollBarVisibility), reinterpret_cast<setter>(ScrollView_put_HorizontalScrollBarVisibility), nullptr, nullptr },
        { "content_orientation", reinterpret_cast<getter>(ScrollView_get_ContentOrientation), reinterpret_cast<setter>(ScrollView_put_ContentOrientation), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(ScrollView_get_Content), reinterpret_cast<setter>(ScrollView_put_Content), nullptr, nullptr },
        { "ignored_input_kinds", reinterpret_cast<getter>(ScrollView_get_IgnoredInputKinds), reinterpret_cast<setter>(ScrollView_put_IgnoredInputKinds), nullptr, nullptr },
        { "horizontal_anchor_ratio", reinterpret_cast<getter>(ScrollView_get_HorizontalAnchorRatio), reinterpret_cast<setter>(ScrollView_put_HorizontalAnchorRatio), nullptr, nullptr },
        { "horizontal_scroll_rail_mode", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollRailMode), reinterpret_cast<setter>(ScrollView_put_HorizontalScrollRailMode), nullptr, nullptr },
        { "zoom_mode", reinterpret_cast<getter>(ScrollView_get_ZoomMode), reinterpret_cast<setter>(ScrollView_put_ZoomMode), nullptr, nullptr },
        { "max_zoom_factor", reinterpret_cast<getter>(ScrollView_get_MaxZoomFactor), reinterpret_cast<setter>(ScrollView_put_MaxZoomFactor), nullptr, nullptr },
        { "zoom_chain_mode", reinterpret_cast<getter>(ScrollView_get_ZoomChainMode), reinterpret_cast<setter>(ScrollView_put_ZoomChainMode), nullptr, nullptr },
        { "vertical_scroll_rail_mode", reinterpret_cast<getter>(ScrollView_get_VerticalScrollRailMode), reinterpret_cast<setter>(ScrollView_put_VerticalScrollRailMode), nullptr, nullptr },
        { "vertical_scroll_mode", reinterpret_cast<getter>(ScrollView_get_VerticalScrollMode), reinterpret_cast<setter>(ScrollView_put_VerticalScrollMode), nullptr, nullptr },
        { "vertical_scroll_chain_mode", reinterpret_cast<getter>(ScrollView_get_VerticalScrollChainMode), reinterpret_cast<setter>(ScrollView_put_VerticalScrollChainMode), nullptr, nullptr },
        { "vertical_scroll_bar_visibility", reinterpret_cast<getter>(ScrollView_get_VerticalScrollBarVisibility), reinterpret_cast<setter>(ScrollView_put_VerticalScrollBarVisibility), nullptr, nullptr },
        { "vertical_anchor_ratio", reinterpret_cast<getter>(ScrollView_get_VerticalAnchorRatio), reinterpret_cast<setter>(ScrollView_put_VerticalAnchorRatio), nullptr, nullptr },
        { "min_zoom_factor", reinterpret_cast<getter>(ScrollView_get_MinZoomFactor), reinterpret_cast<setter>(ScrollView_put_MinZoomFactor), nullptr, nullptr },
        { "computed_horizontal_scroll_mode", reinterpret_cast<getter>(ScrollView_get_ComputedHorizontalScrollMode), nullptr, nullptr, nullptr },
        { "computed_vertical_scroll_bar_visibility", reinterpret_cast<getter>(ScrollView_get_ComputedVerticalScrollBarVisibility), nullptr, nullptr, nullptr },
        { "computed_vertical_scroll_mode", reinterpret_cast<getter>(ScrollView_get_ComputedVerticalScrollMode), nullptr, nullptr, nullptr },
        { "current_anchor", reinterpret_cast<getter>(ScrollView_get_CurrentAnchor), nullptr, nullptr, nullptr },
        { "expression_animation_sources", reinterpret_cast<getter>(ScrollView_get_ExpressionAnimationSources), nullptr, nullptr, nullptr },
        { "extent_height", reinterpret_cast<getter>(ScrollView_get_ExtentHeight), nullptr, nullptr, nullptr },
        { "extent_width", reinterpret_cast<getter>(ScrollView_get_ExtentWidth), nullptr, nullptr, nullptr },
        { "horizontal_offset", reinterpret_cast<getter>(ScrollView_get_HorizontalOffset), nullptr, nullptr, nullptr },
        { "scroll_presenter", reinterpret_cast<getter>(ScrollView_get_ScrollPresenter), nullptr, nullptr, nullptr },
        { "scrollable_height", reinterpret_cast<getter>(ScrollView_get_ScrollableHeight), nullptr, nullptr, nullptr },
        { "scrollable_width", reinterpret_cast<getter>(ScrollView_get_ScrollableWidth), nullptr, nullptr, nullptr },
        { "state", reinterpret_cast<getter>(ScrollView_get_State), nullptr, nullptr, nullptr },
        { "vertical_offset", reinterpret_cast<getter>(ScrollView_get_VerticalOffset), nullptr, nullptr, nullptr },
        { "viewport_height", reinterpret_cast<getter>(ScrollView_get_ViewportHeight), nullptr, nullptr, nullptr },
        { "viewport_width", reinterpret_cast<getter>(ScrollView_get_ViewportWidth), nullptr, nullptr, nullptr },
        { "zoom_factor", reinterpret_cast<getter>(ScrollView_get_ZoomFactor), nullptr, nullptr, nullptr },
        { "computed_horizontal_scroll_bar_visibility", reinterpret_cast<getter>(ScrollView_get_ComputedHorizontalScrollBarVisibility), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollView) },
        { },
    };

    static PyType_Spec type_spec_ScrollView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollView
    };

    static PyGetSetDef getset_ScrollView_Static[] = {
        { "computed_horizontal_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollView_get_ComputedHorizontalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "computed_horizontal_scroll_mode_property", reinterpret_cast<getter>(ScrollView_get_ComputedHorizontalScrollModeProperty), nullptr, nullptr, nullptr },
        { "computed_vertical_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollView_get_ComputedVerticalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "computed_vertical_scroll_mode_property", reinterpret_cast<getter>(ScrollView_get_ComputedVerticalScrollModeProperty), nullptr, nullptr, nullptr },
        { "content_orientation_property", reinterpret_cast<getter>(ScrollView_get_ContentOrientationProperty), nullptr, nullptr, nullptr },
        { "content_property", reinterpret_cast<getter>(ScrollView_get_ContentProperty), nullptr, nullptr, nullptr },
        { "horizontal_anchor_ratio_property", reinterpret_cast<getter>(ScrollView_get_HorizontalAnchorRatioProperty), nullptr, nullptr, nullptr },
        { "horizontal_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "horizontal_scroll_chain_mode_property", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollChainModeProperty), nullptr, nullptr, nullptr },
        { "horizontal_scroll_mode_property", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollModeProperty), nullptr, nullptr, nullptr },
        { "horizontal_scroll_rail_mode_property", reinterpret_cast<getter>(ScrollView_get_HorizontalScrollRailModeProperty), nullptr, nullptr, nullptr },
        { "ignored_input_kinds_property", reinterpret_cast<getter>(ScrollView_get_IgnoredInputKindsProperty), nullptr, nullptr, nullptr },
        { "max_zoom_factor_property", reinterpret_cast<getter>(ScrollView_get_MaxZoomFactorProperty), nullptr, nullptr, nullptr },
        { "min_zoom_factor_property", reinterpret_cast<getter>(ScrollView_get_MinZoomFactorProperty), nullptr, nullptr, nullptr },
        { "scroll_presenter_property", reinterpret_cast<getter>(ScrollView_get_ScrollPresenterProperty), nullptr, nullptr, nullptr },
        { "vertical_anchor_ratio_property", reinterpret_cast<getter>(ScrollView_get_VerticalAnchorRatioProperty), nullptr, nullptr, nullptr },
        { "vertical_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollView_get_VerticalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "vertical_scroll_chain_mode_property", reinterpret_cast<getter>(ScrollView_get_VerticalScrollChainModeProperty), nullptr, nullptr, nullptr },
        { "vertical_scroll_mode_property", reinterpret_cast<getter>(ScrollView_get_VerticalScrollModeProperty), nullptr, nullptr, nullptr },
        { "vertical_scroll_rail_mode_property", reinterpret_cast<getter>(ScrollView_get_VerticalScrollRailModeProperty), nullptr, nullptr, nullptr },
        { "zoom_chain_mode_property", reinterpret_cast<getter>(ScrollView_get_ZoomChainModeProperty), nullptr, nullptr, nullptr },
        { "zoom_mode_property", reinterpret_cast<getter>(ScrollView_get_ZoomModeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ScrollView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ScrollView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ScrollView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ScrollView_Static) },
        { }
    };

    static PyType_Spec type_spec_ScrollView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ScrollView_Static
    };

    // ----- ScrollViewer class --------------------

    static PyObject* _new_ScrollViewer(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::Microsoft::UI::Xaml::Controls::ScrollViewer 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_ScrollViewer(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollViewer_ChangeView(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ChangeView", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IReference<double>>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<double>>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::IReference<float>>(args, 2);

                return py::convert(self->obj.ChangeView(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 4)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ChangeView", 4))
            {
                py::set_arg_count_version_error(4);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IReference<double>>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IReference<double>>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Foundation::IReference<float>>(args, 2);
                auto param3 = py::convert_to<bool>(args, 3);

                return py::convert(self->obj.ChangeView(param0, param1, param2, param3));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetBringIntoViewOnFocusChange(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetBringIntoViewOnFocusChange", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetBringIntoViewOnFocusChange(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetCanContentRenderOutsideBounds(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetCanContentRenderOutsideBounds", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetCanContentRenderOutsideBounds(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetHorizontalScrollBarVisibility(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetHorizontalScrollBarVisibility", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetHorizontalScrollBarVisibility(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetHorizontalScrollMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetHorizontalScrollMode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetHorizontalScrollMode(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsDeferredScrollingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsDeferredScrollingEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsDeferredScrollingEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsHorizontalRailEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsHorizontalRailEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsHorizontalRailEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsHorizontalScrollChainingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsHorizontalScrollChainingEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsHorizontalScrollChainingEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsScrollInertiaEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsScrollInertiaEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsScrollInertiaEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsVerticalRailEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsVerticalRailEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsVerticalRailEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsVerticalScrollChainingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsVerticalScrollChainingEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsVerticalScrollChainingEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsZoomChainingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsZoomChainingEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsZoomChainingEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetIsZoomInertiaEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetIsZoomInertiaEnabled", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetIsZoomInertiaEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetVerticalScrollBarVisibility(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetVerticalScrollBarVisibility", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetVerticalScrollBarVisibility(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetVerticalScrollMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetVerticalScrollMode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetVerticalScrollMode(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_GetZoomMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"GetZoomMode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::GetZoomMode(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_InvalidateScrollInfo(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"InvalidateScrollInfo", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.InvalidateScrollInfo();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_RegisterAnchorCandidate(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"RegisterAnchorCandidate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.RegisterAnchorCandidate(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_ScrollToHorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ScrollToHorizontalOffset", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);

                self->obj.ScrollToHorizontalOffset(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_ScrollToVerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ScrollToVerticalOffset", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<double>(args, 0);

                self->obj.ScrollToVerticalOffset(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetBringIntoViewOnFocusChange(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetBringIntoViewOnFocusChange", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetBringIntoViewOnFocusChange(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetCanContentRenderOutsideBounds(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetCanContentRenderOutsideBounds", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetCanContentRenderOutsideBounds(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetHorizontalScrollBarVisibility(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetHorizontalScrollBarVisibility", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollBarVisibility>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetHorizontalScrollBarVisibility(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetHorizontalScrollMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetHorizontalScrollMode", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollMode>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetHorizontalScrollMode(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsDeferredScrollingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsDeferredScrollingEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsDeferredScrollingEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsHorizontalRailEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsHorizontalRailEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsHorizontalRailEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsHorizontalScrollChainingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsHorizontalScrollChainingEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsHorizontalScrollChainingEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsScrollInertiaEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsScrollInertiaEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsScrollInertiaEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsVerticalRailEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsVerticalRailEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsVerticalRailEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsVerticalScrollChainingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsVerticalScrollChainingEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsVerticalScrollChainingEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsZoomChainingEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsZoomChainingEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsZoomChainingEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetIsZoomInertiaEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetIsZoomInertiaEnabled", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetIsZoomInertiaEnabled(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetVerticalScrollBarVisibility(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetVerticalScrollBarVisibility", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollBarVisibility>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetVerticalScrollBarVisibility(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetVerticalScrollMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetVerticalScrollMode", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollMode>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetVerticalScrollMode(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_SetZoomMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"SetZoomMode", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ZoomMode>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::SetZoomMode(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_UnregisterAnchorCandidate(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"UnregisterAnchorCandidate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.UnregisterAnchorCandidate(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_ZoomToFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomToFactor", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<float>(args, 0);

                self->obj.ZoomToFactor(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_CurrentAnchor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"CurrentAnchor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CurrentAnchor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsHorizontalScrollChainingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsHorizontalScrollChainingEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsHorizontalScrollChainingEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsHorizontalScrollChainingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsHorizontalScrollChainingEnabled"))
        {
            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.IsHorizontalScrollChainingEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_IsHorizontalRailEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsHorizontalRailEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsHorizontalRailEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsHorizontalRailEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsHorizontalRailEnabled"))
        {
            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.IsHorizontalRailEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_IsDeferredScrollingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsDeferredScrollingEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsDeferredScrollingEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsDeferredScrollingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsDeferredScrollingEnabled"))
        {
            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.IsDeferredScrollingEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalSnapPointsType(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalSnapPointsType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalSnapPointsType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_HorizontalSnapPointsType(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalSnapPointsType"))
        {
            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::Microsoft::UI::Xaml::Controls::SnapPointsType>(arg);

            self->obj.HorizontalSnapPointsType(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalSnapPointsAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalSnapPointsAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalSnapPointsAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_HorizontalSnapPointsAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalSnapPointsAlignment"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::SnapPointsAlignment>(arg);

            self->obj.HorizontalSnapPointsAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalScrollMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalScrollMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_HorizontalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalScrollMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollMode>(arg);

            self->obj.HorizontalScrollMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_HorizontalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalScrollBarVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollBarVisibility>(arg);

            self->obj.HorizontalScrollBarVisibility(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_IsZoomInertiaEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsZoomInertiaEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomInertiaEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsZoomInertiaEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsZoomInertiaEnabled"))
        {
            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.IsZoomInertiaEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalAnchorRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalAnchorRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_HorizontalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalAnchorRatio"))
        {
            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<double>(arg);

            self->obj.HorizontalAnchorRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_IsZoomChainingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsZoomChainingEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomChainingEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsZoomChainingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsZoomChainingEnabled"))
        {
            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.IsZoomChainingEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_IsVerticalScrollChainingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsVerticalScrollChainingEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsVerticalScrollChainingEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsVerticalScrollChainingEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsVerticalScrollChainingEnabled"))
        {
            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.IsVerticalScrollChainingEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_IsVerticalRailEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsVerticalRailEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsVerticalRailEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsVerticalRailEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsVerticalRailEnabled"))
        {
            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.IsVerticalRailEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_IsScrollInertiaEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsScrollInertiaEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsScrollInertiaEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_IsScrollInertiaEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsScrollInertiaEnabled"))
        {
            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.IsScrollInertiaEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_CanContentRenderOutsideBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"CanContentRenderOutsideBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanContentRenderOutsideBounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_CanContentRenderOutsideBounds(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"CanContentRenderOutsideBounds"))
        {
            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.CanContentRenderOutsideBounds(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_LeftHeader(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"LeftHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LeftHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_LeftHeader(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"LeftHeader"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.LeftHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_BringIntoViewOnFocusChange(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"BringIntoViewOnFocusChange"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BringIntoViewOnFocusChange());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_BringIntoViewOnFocusChange(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"BringIntoViewOnFocusChange"))
        {
            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.BringIntoViewOnFocusChange(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_ZoomSnapPointsType(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomSnapPointsType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomSnapPointsType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_ZoomSnapPointsType(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomSnapPointsType"))
        {
            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::Microsoft::UI::Xaml::Controls::SnapPointsType>(arg);

            self->obj.ZoomSnapPointsType(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_ZoomMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_ZoomMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ZoomMode>(arg);

            self->obj.ZoomMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_VerticalSnapPointsType(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalSnapPointsType"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalSnapPointsType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_VerticalSnapPointsType(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalSnapPointsType"))
        {
            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::Microsoft::UI::Xaml::Controls::SnapPointsType>(arg);

            self->obj.VerticalSnapPointsType(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_VerticalSnapPointsAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalSnapPointsAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalSnapPointsAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_VerticalSnapPointsAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalSnapPointsAlignment"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::SnapPointsAlignment>(arg);

            self->obj.VerticalSnapPointsAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_VerticalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalScrollMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalScrollMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_VerticalScrollMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalScrollMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollMode>(arg);

            self->obj.VerticalScrollMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_VerticalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_VerticalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalScrollBarVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollBarVisibility>(arg);

            self->obj.VerticalScrollBarVisibility(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_VerticalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalAnchorRatio"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalAnchorRatio());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_VerticalAnchorRatio(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalAnchorRatio"))
        {
            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<double>(arg);

            self->obj.VerticalAnchorRatio(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_TopLeftHeader(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"TopLeftHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopLeftHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_TopLeftHeader(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"TopLeftHeader"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.TopLeftHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_TopHeader(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"TopHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_TopHeader(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"TopHeader"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.TopHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_ReduceViewportForCoreInputViewOcclusions(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ReduceViewportForCoreInputViewOcclusions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ReduceViewportForCoreInputViewOcclusions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_ReduceViewportForCoreInputViewOcclusions(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ReduceViewportForCoreInputViewOcclusions"))
        {
            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.ReduceViewportForCoreInputViewOcclusions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_MinZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"MinZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_MinZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"MinZoomFactor"))
        {
            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<float>(arg);

            self->obj.MinZoomFactor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_MaxZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"MaxZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollViewer_put_MaxZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"MaxZoomFactor"))
        {
            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<float>(arg);

            self->obj.MaxZoomFactor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollViewer_get_ComputedHorizontalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ComputedHorizontalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ComputedHorizontalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ComputedVerticalScrollBarVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ComputedVerticalScrollBarVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ComputedVerticalScrollBarVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ExtentHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ExtentHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExtentHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ExtentWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ExtentWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExtentWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ScrollableHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ScrollableHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollableHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ScrollableWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ScrollableWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ScrollableWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_VerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ViewportHeight(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewportHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ViewportHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ViewportWidth(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewportWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ViewportWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ZoomSnapPoints(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomSnapPoints"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomSnapPoints());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_BringIntoViewOnFocusChangeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"BringIntoViewOnFocusChangeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::BringIntoViewOnFocusChangeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_CanContentRenderOutsideBoundsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"CanContentRenderOutsideBoundsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::CanContentRenderOutsideBoundsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ComputedHorizontalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ComputedHorizontalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ComputedHorizontalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ComputedVerticalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ComputedVerticalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ComputedVerticalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ExtentHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ExtentHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ExtentHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ExtentWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ExtentWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ExtentWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalAnchorRatioProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalAnchorRatioProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::HorizontalAnchorRatioProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::HorizontalOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::HorizontalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalScrollModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalScrollModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::HorizontalScrollModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalSnapPointsAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalSnapPointsAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::HorizontalSnapPointsAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_HorizontalSnapPointsTypeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"HorizontalSnapPointsTypeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::HorizontalSnapPointsTypeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsDeferredScrollingEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsDeferredScrollingEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsDeferredScrollingEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsHorizontalRailEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsHorizontalRailEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsHorizontalRailEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsHorizontalScrollChainingEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsHorizontalScrollChainingEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsHorizontalScrollChainingEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsScrollInertiaEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsScrollInertiaEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsScrollInertiaEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsVerticalRailEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsVerticalRailEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsVerticalRailEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsVerticalScrollChainingEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsVerticalScrollChainingEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsVerticalScrollChainingEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsZoomChainingEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsZoomChainingEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsZoomChainingEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_IsZoomInertiaEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"IsZoomInertiaEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::IsZoomInertiaEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_LeftHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"LeftHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::LeftHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_MaxZoomFactorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"MaxZoomFactorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::MaxZoomFactorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_MinZoomFactorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"MinZoomFactorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::MinZoomFactorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ReduceViewportForCoreInputViewOcclusionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ReduceViewportForCoreInputViewOcclusionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ReduceViewportForCoreInputViewOcclusionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ScrollableHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ScrollableHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ScrollableHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ScrollableWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ScrollableWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ScrollableWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_TopHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"TopHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::TopHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_TopLeftHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"TopLeftHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::TopLeftHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_VerticalAnchorRatioProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalAnchorRatioProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::VerticalAnchorRatioProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_VerticalOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::VerticalOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_VerticalScrollBarVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalScrollBarVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::VerticalScrollBarVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_VerticalScrollModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalScrollModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::VerticalScrollModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_VerticalSnapPointsAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalSnapPointsAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::VerticalSnapPointsAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_VerticalSnapPointsTypeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"VerticalSnapPointsTypeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::VerticalSnapPointsTypeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ViewportHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewportHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ViewportHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ViewportWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewportWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ViewportWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ZoomFactorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomFactorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ZoomFactorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ZoomModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ZoomModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ZoomSnapPointsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomSnapPointsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ZoomSnapPointsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_get_ZoomSnapPointsTypeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ZoomSnapPointsTypeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ScrollViewer::ZoomSnapPointsTypeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_add_AnchorRequested(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"AnchorRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollViewer, winrt::Microsoft::UI::Xaml::Controls::AnchorRequestedEventArgs>>(arg);

            return py::convert(self->obj.AnchorRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_remove_AnchorRequested(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"AnchorRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.AnchorRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_add_DirectManipulationCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"DirectManipulationCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.DirectManipulationCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_remove_DirectManipulationCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"DirectManipulationCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.DirectManipulationCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_add_DirectManipulationStarted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"DirectManipulationStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.DirectManipulationStarted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_remove_DirectManipulationStarted(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"DirectManipulationStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.DirectManipulationStarted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_add_ViewChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs>>(arg);

            return py::convert(self->obj.ViewChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_remove_ViewChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ViewChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_add_ViewChanging(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs>>(arg);

            return py::convert(self->obj.ViewChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewer_remove_ViewChanging(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewer", L"ViewChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ViewChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollViewer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollViewer>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollViewer(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollViewer>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollViewer[] = {
        { "change_view", reinterpret_cast<PyCFunction>(ScrollViewer_ChangeView), METH_VARARGS, nullptr },
        { "invalidate_scroll_info", reinterpret_cast<PyCFunction>(ScrollViewer_InvalidateScrollInfo), METH_VARARGS, nullptr },
        { "register_anchor_candidate", reinterpret_cast<PyCFunction>(ScrollViewer_RegisterAnchorCandidate), METH_VARARGS, nullptr },
        { "scroll_to_horizontal_offset", reinterpret_cast<PyCFunction>(ScrollViewer_ScrollToHorizontalOffset), METH_VARARGS, nullptr },
        { "scroll_to_vertical_offset", reinterpret_cast<PyCFunction>(ScrollViewer_ScrollToVerticalOffset), METH_VARARGS, nullptr },
        { "unregister_anchor_candidate", reinterpret_cast<PyCFunction>(ScrollViewer_UnregisterAnchorCandidate), METH_VARARGS, nullptr },
        { "zoom_to_factor", reinterpret_cast<PyCFunction>(ScrollViewer_ZoomToFactor), METH_VARARGS, nullptr },
        { "add_anchor_requested", reinterpret_cast<PyCFunction>(ScrollViewer_add_AnchorRequested), METH_O, nullptr },
        { "remove_anchor_requested", reinterpret_cast<PyCFunction>(ScrollViewer_remove_AnchorRequested), METH_O, nullptr },
        { "add_direct_manipulation_completed", reinterpret_cast<PyCFunction>(ScrollViewer_add_DirectManipulationCompleted), METH_O, nullptr },
        { "remove_direct_manipulation_completed", reinterpret_cast<PyCFunction>(ScrollViewer_remove_DirectManipulationCompleted), METH_O, nullptr },
        { "add_direct_manipulation_started", reinterpret_cast<PyCFunction>(ScrollViewer_add_DirectManipulationStarted), METH_O, nullptr },
        { "remove_direct_manipulation_started", reinterpret_cast<PyCFunction>(ScrollViewer_remove_DirectManipulationStarted), METH_O, nullptr },
        { "add_view_changed", reinterpret_cast<PyCFunction>(ScrollViewer_add_ViewChanged), METH_O, nullptr },
        { "remove_view_changed", reinterpret_cast<PyCFunction>(ScrollViewer_remove_ViewChanged), METH_O, nullptr },
        { "add_view_changing", reinterpret_cast<PyCFunction>(ScrollViewer_add_ViewChanging), METH_O, nullptr },
        { "remove_view_changing", reinterpret_cast<PyCFunction>(ScrollViewer_remove_ViewChanging), METH_O, nullptr },
        { "_assign_array_", _assign_array_ScrollViewer, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollViewer), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollViewer[] = {
        { "current_anchor", reinterpret_cast<getter>(ScrollViewer_get_CurrentAnchor), nullptr, nullptr, nullptr },
        { "is_horizontal_scroll_chaining_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsHorizontalScrollChainingEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsHorizontalScrollChainingEnabled), nullptr, nullptr },
        { "is_horizontal_rail_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsHorizontalRailEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsHorizontalRailEnabled), nullptr, nullptr },
        { "is_deferred_scrolling_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsDeferredScrollingEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsDeferredScrollingEnabled), nullptr, nullptr },
        { "horizontal_snap_points_type", reinterpret_cast<getter>(ScrollViewer_get_HorizontalSnapPointsType), reinterpret_cast<setter>(ScrollViewer_put_HorizontalSnapPointsType), nullptr, nullptr },
        { "horizontal_snap_points_alignment", reinterpret_cast<getter>(ScrollViewer_get_HorizontalSnapPointsAlignment), reinterpret_cast<setter>(ScrollViewer_put_HorizontalSnapPointsAlignment), nullptr, nullptr },
        { "horizontal_scroll_mode", reinterpret_cast<getter>(ScrollViewer_get_HorizontalScrollMode), reinterpret_cast<setter>(ScrollViewer_put_HorizontalScrollMode), nullptr, nullptr },
        { "horizontal_scroll_bar_visibility", reinterpret_cast<getter>(ScrollViewer_get_HorizontalScrollBarVisibility), reinterpret_cast<setter>(ScrollViewer_put_HorizontalScrollBarVisibility), nullptr, nullptr },
        { "is_zoom_inertia_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsZoomInertiaEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsZoomInertiaEnabled), nullptr, nullptr },
        { "horizontal_anchor_ratio", reinterpret_cast<getter>(ScrollViewer_get_HorizontalAnchorRatio), reinterpret_cast<setter>(ScrollViewer_put_HorizontalAnchorRatio), nullptr, nullptr },
        { "is_zoom_chaining_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsZoomChainingEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsZoomChainingEnabled), nullptr, nullptr },
        { "is_vertical_scroll_chaining_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsVerticalScrollChainingEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsVerticalScrollChainingEnabled), nullptr, nullptr },
        { "is_vertical_rail_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsVerticalRailEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsVerticalRailEnabled), nullptr, nullptr },
        { "is_scroll_inertia_enabled", reinterpret_cast<getter>(ScrollViewer_get_IsScrollInertiaEnabled), reinterpret_cast<setter>(ScrollViewer_put_IsScrollInertiaEnabled), nullptr, nullptr },
        { "can_content_render_outside_bounds", reinterpret_cast<getter>(ScrollViewer_get_CanContentRenderOutsideBounds), reinterpret_cast<setter>(ScrollViewer_put_CanContentRenderOutsideBounds), nullptr, nullptr },
        { "left_header", reinterpret_cast<getter>(ScrollViewer_get_LeftHeader), reinterpret_cast<setter>(ScrollViewer_put_LeftHeader), nullptr, nullptr },
        { "bring_into_view_on_focus_change", reinterpret_cast<getter>(ScrollViewer_get_BringIntoViewOnFocusChange), reinterpret_cast<setter>(ScrollViewer_put_BringIntoViewOnFocusChange), nullptr, nullptr },
        { "zoom_snap_points_type", reinterpret_cast<getter>(ScrollViewer_get_ZoomSnapPointsType), reinterpret_cast<setter>(ScrollViewer_put_ZoomSnapPointsType), nullptr, nullptr },
        { "zoom_mode", reinterpret_cast<getter>(ScrollViewer_get_ZoomMode), reinterpret_cast<setter>(ScrollViewer_put_ZoomMode), nullptr, nullptr },
        { "vertical_snap_points_type", reinterpret_cast<getter>(ScrollViewer_get_VerticalSnapPointsType), reinterpret_cast<setter>(ScrollViewer_put_VerticalSnapPointsType), nullptr, nullptr },
        { "vertical_snap_points_alignment", reinterpret_cast<getter>(ScrollViewer_get_VerticalSnapPointsAlignment), reinterpret_cast<setter>(ScrollViewer_put_VerticalSnapPointsAlignment), nullptr, nullptr },
        { "vertical_scroll_mode", reinterpret_cast<getter>(ScrollViewer_get_VerticalScrollMode), reinterpret_cast<setter>(ScrollViewer_put_VerticalScrollMode), nullptr, nullptr },
        { "vertical_scroll_bar_visibility", reinterpret_cast<getter>(ScrollViewer_get_VerticalScrollBarVisibility), reinterpret_cast<setter>(ScrollViewer_put_VerticalScrollBarVisibility), nullptr, nullptr },
        { "vertical_anchor_ratio", reinterpret_cast<getter>(ScrollViewer_get_VerticalAnchorRatio), reinterpret_cast<setter>(ScrollViewer_put_VerticalAnchorRatio), nullptr, nullptr },
        { "top_left_header", reinterpret_cast<getter>(ScrollViewer_get_TopLeftHeader), reinterpret_cast<setter>(ScrollViewer_put_TopLeftHeader), nullptr, nullptr },
        { "top_header", reinterpret_cast<getter>(ScrollViewer_get_TopHeader), reinterpret_cast<setter>(ScrollViewer_put_TopHeader), nullptr, nullptr },
        { "reduce_viewport_for_core_input_view_occlusions", reinterpret_cast<getter>(ScrollViewer_get_ReduceViewportForCoreInputViewOcclusions), reinterpret_cast<setter>(ScrollViewer_put_ReduceViewportForCoreInputViewOcclusions), nullptr, nullptr },
        { "min_zoom_factor", reinterpret_cast<getter>(ScrollViewer_get_MinZoomFactor), reinterpret_cast<setter>(ScrollViewer_put_MinZoomFactor), nullptr, nullptr },
        { "max_zoom_factor", reinterpret_cast<getter>(ScrollViewer_get_MaxZoomFactor), reinterpret_cast<setter>(ScrollViewer_put_MaxZoomFactor), nullptr, nullptr },
        { "computed_horizontal_scroll_bar_visibility", reinterpret_cast<getter>(ScrollViewer_get_ComputedHorizontalScrollBarVisibility), nullptr, nullptr, nullptr },
        { "computed_vertical_scroll_bar_visibility", reinterpret_cast<getter>(ScrollViewer_get_ComputedVerticalScrollBarVisibility), nullptr, nullptr, nullptr },
        { "extent_height", reinterpret_cast<getter>(ScrollViewer_get_ExtentHeight), nullptr, nullptr, nullptr },
        { "extent_width", reinterpret_cast<getter>(ScrollViewer_get_ExtentWidth), nullptr, nullptr, nullptr },
        { "horizontal_offset", reinterpret_cast<getter>(ScrollViewer_get_HorizontalOffset), nullptr, nullptr, nullptr },
        { "scrollable_height", reinterpret_cast<getter>(ScrollViewer_get_ScrollableHeight), nullptr, nullptr, nullptr },
        { "scrollable_width", reinterpret_cast<getter>(ScrollViewer_get_ScrollableWidth), nullptr, nullptr, nullptr },
        { "vertical_offset", reinterpret_cast<getter>(ScrollViewer_get_VerticalOffset), nullptr, nullptr, nullptr },
        { "viewport_height", reinterpret_cast<getter>(ScrollViewer_get_ViewportHeight), nullptr, nullptr, nullptr },
        { "viewport_width", reinterpret_cast<getter>(ScrollViewer_get_ViewportWidth), nullptr, nullptr, nullptr },
        { "zoom_factor", reinterpret_cast<getter>(ScrollViewer_get_ZoomFactor), nullptr, nullptr, nullptr },
        { "zoom_snap_points", reinterpret_cast<getter>(ScrollViewer_get_ZoomSnapPoints), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollViewer[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollViewer) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollViewer) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollViewer) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollViewer) },
        { },
    };

    static PyType_Spec type_spec_ScrollViewer =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollViewer",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewer),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollViewer
    };

    static PyGetSetDef getset_ScrollViewer_Static[] = {
        { "bring_into_view_on_focus_change_property", reinterpret_cast<getter>(ScrollViewer_get_BringIntoViewOnFocusChangeProperty), nullptr, nullptr, nullptr },
        { "can_content_render_outside_bounds_property", reinterpret_cast<getter>(ScrollViewer_get_CanContentRenderOutsideBoundsProperty), nullptr, nullptr, nullptr },
        { "computed_horizontal_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollViewer_get_ComputedHorizontalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "computed_vertical_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollViewer_get_ComputedVerticalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "extent_height_property", reinterpret_cast<getter>(ScrollViewer_get_ExtentHeightProperty), nullptr, nullptr, nullptr },
        { "extent_width_property", reinterpret_cast<getter>(ScrollViewer_get_ExtentWidthProperty), nullptr, nullptr, nullptr },
        { "horizontal_anchor_ratio_property", reinterpret_cast<getter>(ScrollViewer_get_HorizontalAnchorRatioProperty), nullptr, nullptr, nullptr },
        { "horizontal_offset_property", reinterpret_cast<getter>(ScrollViewer_get_HorizontalOffsetProperty), nullptr, nullptr, nullptr },
        { "horizontal_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollViewer_get_HorizontalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "horizontal_scroll_mode_property", reinterpret_cast<getter>(ScrollViewer_get_HorizontalScrollModeProperty), nullptr, nullptr, nullptr },
        { "horizontal_snap_points_alignment_property", reinterpret_cast<getter>(ScrollViewer_get_HorizontalSnapPointsAlignmentProperty), nullptr, nullptr, nullptr },
        { "horizontal_snap_points_type_property", reinterpret_cast<getter>(ScrollViewer_get_HorizontalSnapPointsTypeProperty), nullptr, nullptr, nullptr },
        { "is_deferred_scrolling_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsDeferredScrollingEnabledProperty), nullptr, nullptr, nullptr },
        { "is_horizontal_rail_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsHorizontalRailEnabledProperty), nullptr, nullptr, nullptr },
        { "is_horizontal_scroll_chaining_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsHorizontalScrollChainingEnabledProperty), nullptr, nullptr, nullptr },
        { "is_scroll_inertia_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsScrollInertiaEnabledProperty), nullptr, nullptr, nullptr },
        { "is_vertical_rail_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsVerticalRailEnabledProperty), nullptr, nullptr, nullptr },
        { "is_vertical_scroll_chaining_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsVerticalScrollChainingEnabledProperty), nullptr, nullptr, nullptr },
        { "is_zoom_chaining_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsZoomChainingEnabledProperty), nullptr, nullptr, nullptr },
        { "is_zoom_inertia_enabled_property", reinterpret_cast<getter>(ScrollViewer_get_IsZoomInertiaEnabledProperty), nullptr, nullptr, nullptr },
        { "left_header_property", reinterpret_cast<getter>(ScrollViewer_get_LeftHeaderProperty), nullptr, nullptr, nullptr },
        { "max_zoom_factor_property", reinterpret_cast<getter>(ScrollViewer_get_MaxZoomFactorProperty), nullptr, nullptr, nullptr },
        { "min_zoom_factor_property", reinterpret_cast<getter>(ScrollViewer_get_MinZoomFactorProperty), nullptr, nullptr, nullptr },
        { "reduce_viewport_for_core_input_view_occlusions_property", reinterpret_cast<getter>(ScrollViewer_get_ReduceViewportForCoreInputViewOcclusionsProperty), nullptr, nullptr, nullptr },
        { "scrollable_height_property", reinterpret_cast<getter>(ScrollViewer_get_ScrollableHeightProperty), nullptr, nullptr, nullptr },
        { "scrollable_width_property", reinterpret_cast<getter>(ScrollViewer_get_ScrollableWidthProperty), nullptr, nullptr, nullptr },
        { "top_header_property", reinterpret_cast<getter>(ScrollViewer_get_TopHeaderProperty), nullptr, nullptr, nullptr },
        { "top_left_header_property", reinterpret_cast<getter>(ScrollViewer_get_TopLeftHeaderProperty), nullptr, nullptr, nullptr },
        { "vertical_anchor_ratio_property", reinterpret_cast<getter>(ScrollViewer_get_VerticalAnchorRatioProperty), nullptr, nullptr, nullptr },
        { "vertical_offset_property", reinterpret_cast<getter>(ScrollViewer_get_VerticalOffsetProperty), nullptr, nullptr, nullptr },
        { "vertical_scroll_bar_visibility_property", reinterpret_cast<getter>(ScrollViewer_get_VerticalScrollBarVisibilityProperty), nullptr, nullptr, nullptr },
        { "vertical_scroll_mode_property", reinterpret_cast<getter>(ScrollViewer_get_VerticalScrollModeProperty), nullptr, nullptr, nullptr },
        { "vertical_snap_points_alignment_property", reinterpret_cast<getter>(ScrollViewer_get_VerticalSnapPointsAlignmentProperty), nullptr, nullptr, nullptr },
        { "vertical_snap_points_type_property", reinterpret_cast<getter>(ScrollViewer_get_VerticalSnapPointsTypeProperty), nullptr, nullptr, nullptr },
        { "viewport_height_property", reinterpret_cast<getter>(ScrollViewer_get_ViewportHeightProperty), nullptr, nullptr, nullptr },
        { "viewport_width_property", reinterpret_cast<getter>(ScrollViewer_get_ViewportWidthProperty), nullptr, nullptr, nullptr },
        { "zoom_factor_property", reinterpret_cast<getter>(ScrollViewer_get_ZoomFactorProperty), nullptr, nullptr, nullptr },
        { "zoom_mode_property", reinterpret_cast<getter>(ScrollViewer_get_ZoomModeProperty), nullptr, nullptr, nullptr },
        { "zoom_snap_points_property", reinterpret_cast<getter>(ScrollViewer_get_ZoomSnapPointsProperty), nullptr, nullptr, nullptr },
        { "zoom_snap_points_type_property", reinterpret_cast<getter>(ScrollViewer_get_ZoomSnapPointsTypeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ScrollViewer_Static[] = {
        { "get_bring_into_view_on_focus_change", reinterpret_cast<PyCFunction>(ScrollViewer_GetBringIntoViewOnFocusChange), METH_VARARGS, nullptr },
        { "get_can_content_render_outside_bounds", reinterpret_cast<PyCFunction>(ScrollViewer_GetCanContentRenderOutsideBounds), METH_VARARGS, nullptr },
        { "get_horizontal_scroll_bar_visibility", reinterpret_cast<PyCFunction>(ScrollViewer_GetHorizontalScrollBarVisibility), METH_VARARGS, nullptr },
        { "get_horizontal_scroll_mode", reinterpret_cast<PyCFunction>(ScrollViewer_GetHorizontalScrollMode), METH_VARARGS, nullptr },
        { "get_is_deferred_scrolling_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsDeferredScrollingEnabled), METH_VARARGS, nullptr },
        { "get_is_horizontal_rail_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsHorizontalRailEnabled), METH_VARARGS, nullptr },
        { "get_is_horizontal_scroll_chaining_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsHorizontalScrollChainingEnabled), METH_VARARGS, nullptr },
        { "get_is_scroll_inertia_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsScrollInertiaEnabled), METH_VARARGS, nullptr },
        { "get_is_vertical_rail_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsVerticalRailEnabled), METH_VARARGS, nullptr },
        { "get_is_vertical_scroll_chaining_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsVerticalScrollChainingEnabled), METH_VARARGS, nullptr },
        { "get_is_zoom_chaining_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsZoomChainingEnabled), METH_VARARGS, nullptr },
        { "get_is_zoom_inertia_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_GetIsZoomInertiaEnabled), METH_VARARGS, nullptr },
        { "get_vertical_scroll_bar_visibility", reinterpret_cast<PyCFunction>(ScrollViewer_GetVerticalScrollBarVisibility), METH_VARARGS, nullptr },
        { "get_vertical_scroll_mode", reinterpret_cast<PyCFunction>(ScrollViewer_GetVerticalScrollMode), METH_VARARGS, nullptr },
        { "get_zoom_mode", reinterpret_cast<PyCFunction>(ScrollViewer_GetZoomMode), METH_VARARGS, nullptr },
        { "set_bring_into_view_on_focus_change", reinterpret_cast<PyCFunction>(ScrollViewer_SetBringIntoViewOnFocusChange), METH_VARARGS, nullptr },
        { "set_can_content_render_outside_bounds", reinterpret_cast<PyCFunction>(ScrollViewer_SetCanContentRenderOutsideBounds), METH_VARARGS, nullptr },
        { "set_horizontal_scroll_bar_visibility", reinterpret_cast<PyCFunction>(ScrollViewer_SetHorizontalScrollBarVisibility), METH_VARARGS, nullptr },
        { "set_horizontal_scroll_mode", reinterpret_cast<PyCFunction>(ScrollViewer_SetHorizontalScrollMode), METH_VARARGS, nullptr },
        { "set_is_deferred_scrolling_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsDeferredScrollingEnabled), METH_VARARGS, nullptr },
        { "set_is_horizontal_rail_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsHorizontalRailEnabled), METH_VARARGS, nullptr },
        { "set_is_horizontal_scroll_chaining_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsHorizontalScrollChainingEnabled), METH_VARARGS, nullptr },
        { "set_is_scroll_inertia_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsScrollInertiaEnabled), METH_VARARGS, nullptr },
        { "set_is_vertical_rail_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsVerticalRailEnabled), METH_VARARGS, nullptr },
        { "set_is_vertical_scroll_chaining_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsVerticalScrollChainingEnabled), METH_VARARGS, nullptr },
        { "set_is_zoom_chaining_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsZoomChainingEnabled), METH_VARARGS, nullptr },
        { "set_is_zoom_inertia_enabled", reinterpret_cast<PyCFunction>(ScrollViewer_SetIsZoomInertiaEnabled), METH_VARARGS, nullptr },
        { "set_vertical_scroll_bar_visibility", reinterpret_cast<PyCFunction>(ScrollViewer_SetVerticalScrollBarVisibility), METH_VARARGS, nullptr },
        { "set_vertical_scroll_mode", reinterpret_cast<PyCFunction>(ScrollViewer_SetVerticalScrollMode), METH_VARARGS, nullptr },
        { "set_zoom_mode", reinterpret_cast<PyCFunction>(ScrollViewer_SetZoomMode), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_ScrollViewer_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ScrollViewer_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ScrollViewer_Static) },
        { }
    };

    static PyType_Spec type_spec_ScrollViewer_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollViewer_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ScrollViewer_Static
    };

    // ----- ScrollViewerView class --------------------

    static PyObject* _new_ScrollViewerView(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerView>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerView>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollViewerView(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollViewerView_get_HorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewerView", L"HorizontalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewerView_get_VerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewerView", L"VerticalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewerView_get_ZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewerView", L"ZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollViewerView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollViewerView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollViewerView[] = {
        { "_assign_array_", _assign_array_ScrollViewerView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollViewerView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollViewerView[] = {
        { "horizontal_offset", reinterpret_cast<getter>(ScrollViewerView_get_HorizontalOffset), nullptr, nullptr, nullptr },
        { "vertical_offset", reinterpret_cast<getter>(ScrollViewerView_get_VerticalOffset), nullptr, nullptr, nullptr },
        { "zoom_factor", reinterpret_cast<getter>(ScrollViewerView_get_ZoomFactor), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollViewerView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollViewerView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollViewerView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollViewerView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollViewerView) },
        { },
    };

    static PyType_Spec type_spec_ScrollViewerView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollViewerView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollViewerView
    };

    // ----- ScrollViewerViewChangedEventArgs class --------------------

    static PyObject* _new_ScrollViewerViewChangedEventArgs(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::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs 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_ScrollViewerViewChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollViewerViewChangedEventArgs_get_IsIntermediate(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs", L"IsIntermediate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsIntermediate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollViewerViewChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollViewerViewChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollViewerViewChangedEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollViewerViewChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollViewerViewChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollViewerViewChangedEventArgs[] = {
        { "is_intermediate", reinterpret_cast<getter>(ScrollViewerViewChangedEventArgs_get_IsIntermediate), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollViewerViewChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollViewerViewChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollViewerViewChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollViewerViewChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollViewerViewChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollViewerViewChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollViewerViewChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollViewerViewChangedEventArgs
    };

    // ----- ScrollViewerViewChangingEventArgs class --------------------

    static PyObject* _new_ScrollViewerViewChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollViewerViewChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollViewerViewChangingEventArgs_get_FinalView(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs", L"FinalView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FinalView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewerViewChangingEventArgs_get_IsInertial(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs", L"IsInertial"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsInertial());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollViewerViewChangingEventArgs_get_NextView(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs", L"NextView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NextView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollViewerViewChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollViewerViewChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollViewerViewChangingEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollViewerViewChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollViewerViewChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollViewerViewChangingEventArgs[] = {
        { "final_view", reinterpret_cast<getter>(ScrollViewerViewChangingEventArgs_get_FinalView), nullptr, nullptr, nullptr },
        { "is_inertial", reinterpret_cast<getter>(ScrollViewerViewChangingEventArgs_get_IsInertial), nullptr, nullptr, nullptr },
        { "next_view", reinterpret_cast<getter>(ScrollViewerViewChangingEventArgs_get_NextView), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollViewerViewChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollViewerViewChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollViewerViewChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollViewerViewChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollViewerViewChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollViewerViewChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollViewerViewChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollViewerViewChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollViewerViewChangingEventArgs
    };

    // ----- ScrollingAnchorRequestedEventArgs class --------------------

    static PyObject* _new_ScrollingAnchorRequestedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollingAnchorRequestedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingAnchorRequestedEventArgs_get_AnchorElement(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingAnchorRequestedEventArgs", L"AnchorElement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AnchorElement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingAnchorRequestedEventArgs_put_AnchorElement(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingAnchorRequestedEventArgs", L"AnchorElement"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.AnchorElement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollingAnchorRequestedEventArgs_get_AnchorCandidates(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingAnchorRequestedEventArgs", L"AnchorCandidates"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AnchorCandidates());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollingAnchorRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingAnchorRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingAnchorRequestedEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollingAnchorRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingAnchorRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingAnchorRequestedEventArgs[] = {
        { "anchor_element", reinterpret_cast<getter>(ScrollingAnchorRequestedEventArgs_get_AnchorElement), reinterpret_cast<setter>(ScrollingAnchorRequestedEventArgs_put_AnchorElement), nullptr, nullptr },
        { "anchor_candidates", reinterpret_cast<getter>(ScrollingAnchorRequestedEventArgs_get_AnchorCandidates), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingAnchorRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingAnchorRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingAnchorRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingAnchorRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingAnchorRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollingAnchorRequestedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingAnchorRequestedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingAnchorRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingAnchorRequestedEventArgs
    };

    // ----- ScrollingBringingIntoViewEventArgs class --------------------

    static PyObject* _new_ScrollingBringingIntoViewEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollingBringingIntoViewEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingBringingIntoViewEventArgs_get_SnapPointsMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"SnapPointsMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SnapPointsMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingBringingIntoViewEventArgs_put_SnapPointsMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"SnapPointsMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingSnapPointsMode>(arg);

            self->obj.SnapPointsMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollingBringingIntoViewEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingBringingIntoViewEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollingBringingIntoViewEventArgs_get_CorrelationId(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"CorrelationId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CorrelationId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingBringingIntoViewEventArgs_get_RequestEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"RequestEventArgs"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RequestEventArgs());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingBringingIntoViewEventArgs_get_TargetHorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"TargetHorizontalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TargetHorizontalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingBringingIntoViewEventArgs_get_TargetVerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs", L"TargetVerticalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TargetVerticalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollingBringingIntoViewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingBringingIntoViewEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingBringingIntoViewEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollingBringingIntoViewEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingBringingIntoViewEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingBringingIntoViewEventArgs[] = {
        { "snap_points_mode", reinterpret_cast<getter>(ScrollingBringingIntoViewEventArgs_get_SnapPointsMode), reinterpret_cast<setter>(ScrollingBringingIntoViewEventArgs_put_SnapPointsMode), nullptr, nullptr },
        { "cancel", reinterpret_cast<getter>(ScrollingBringingIntoViewEventArgs_get_Cancel), reinterpret_cast<setter>(ScrollingBringingIntoViewEventArgs_put_Cancel), nullptr, nullptr },
        { "correlation_id", reinterpret_cast<getter>(ScrollingBringingIntoViewEventArgs_get_CorrelationId), nullptr, nullptr, nullptr },
        { "request_event_args", reinterpret_cast<getter>(ScrollingBringingIntoViewEventArgs_get_RequestEventArgs), nullptr, nullptr, nullptr },
        { "target_horizontal_offset", reinterpret_cast<getter>(ScrollingBringingIntoViewEventArgs_get_TargetHorizontalOffset), nullptr, nullptr, nullptr },
        { "target_vertical_offset", reinterpret_cast<getter>(ScrollingBringingIntoViewEventArgs_get_TargetVerticalOffset), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingBringingIntoViewEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingBringingIntoViewEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingBringingIntoViewEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingBringingIntoViewEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingBringingIntoViewEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollingBringingIntoViewEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingBringingIntoViewEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingBringingIntoViewEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingBringingIntoViewEventArgs
    };

    // ----- ScrollingScrollAnimationStartingEventArgs class --------------------

    static PyObject* _new_ScrollingScrollAnimationStartingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollingScrollAnimationStartingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingScrollAnimationStartingEventArgs_get_Animation(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs", L"Animation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Animation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingScrollAnimationStartingEventArgs_put_Animation(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs", L"Animation"))
        {
            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::Microsoft::UI::Composition::CompositionAnimation>(arg);

            self->obj.Animation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollingScrollAnimationStartingEventArgs_get_CorrelationId(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs", L"CorrelationId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CorrelationId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingScrollAnimationStartingEventArgs_get_EndPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs", L"EndPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EndPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingScrollAnimationStartingEventArgs_get_StartPosition(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs", L"StartPosition"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.StartPosition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollingScrollAnimationStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingScrollAnimationStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingScrollAnimationStartingEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollingScrollAnimationStartingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingScrollAnimationStartingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingScrollAnimationStartingEventArgs[] = {
        { "animation", reinterpret_cast<getter>(ScrollingScrollAnimationStartingEventArgs_get_Animation), reinterpret_cast<setter>(ScrollingScrollAnimationStartingEventArgs_put_Animation), nullptr, nullptr },
        { "correlation_id", reinterpret_cast<getter>(ScrollingScrollAnimationStartingEventArgs_get_CorrelationId), nullptr, nullptr, nullptr },
        { "end_position", reinterpret_cast<getter>(ScrollingScrollAnimationStartingEventArgs_get_EndPosition), nullptr, nullptr, nullptr },
        { "start_position", reinterpret_cast<getter>(ScrollingScrollAnimationStartingEventArgs_get_StartPosition), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingScrollAnimationStartingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingScrollAnimationStartingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingScrollAnimationStartingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingScrollAnimationStartingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingScrollAnimationStartingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollingScrollAnimationStartingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingScrollAnimationStartingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollAnimationStartingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingScrollAnimationStartingEventArgs
    };

    // ----- ScrollingScrollCompletedEventArgs class --------------------

    static PyObject* _new_ScrollingScrollCompletedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollingScrollCompletedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingScrollCompletedEventArgs_get_CorrelationId(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollCompletedEventArgs", L"CorrelationId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CorrelationId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollingScrollCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingScrollCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingScrollCompletedEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollingScrollCompletedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingScrollCompletedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingScrollCompletedEventArgs[] = {
        { "correlation_id", reinterpret_cast<getter>(ScrollingScrollCompletedEventArgs_get_CorrelationId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingScrollCompletedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingScrollCompletedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingScrollCompletedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingScrollCompletedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingScrollCompletedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollingScrollCompletedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingScrollCompletedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollCompletedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingScrollCompletedEventArgs
    };

    // ----- ScrollingScrollOptions class --------------------

    static PyObject* _new_ScrollingScrollOptions(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnimationMode>(args, 0);

                winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnimationMode>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingSnapPointsMode>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions instance{ param0, param1 };
                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_ScrollingScrollOptions(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingScrollOptions_get_SnapPointsMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollOptions", L"SnapPointsMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SnapPointsMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingScrollOptions_put_SnapPointsMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollOptions", L"SnapPointsMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingSnapPointsMode>(arg);

            self->obj.SnapPointsMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollingScrollOptions_get_AnimationMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollOptions", L"AnimationMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AnimationMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingScrollOptions_put_AnimationMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingScrollOptions", L"AnimationMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingAnimationMode>(arg);

            self->obj.AnimationMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_ScrollingScrollOptions(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingScrollOptions(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingScrollOptions[] = {
        { "_assign_array_", _assign_array_ScrollingScrollOptions, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingScrollOptions), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingScrollOptions[] = {
        { "snap_points_mode", reinterpret_cast<getter>(ScrollingScrollOptions_get_SnapPointsMode), reinterpret_cast<setter>(ScrollingScrollOptions_put_SnapPointsMode), nullptr, nullptr },
        { "animation_mode", reinterpret_cast<getter>(ScrollingScrollOptions_get_AnimationMode), reinterpret_cast<setter>(ScrollingScrollOptions_put_AnimationMode), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingScrollOptions[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingScrollOptions) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingScrollOptions) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingScrollOptions) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingScrollOptions) },
        { },
    };

    static PyType_Spec type_spec_ScrollingScrollOptions =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingScrollOptions",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingScrollOptions),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingScrollOptions
    };

    // ----- ScrollingZoomAnimationStartingEventArgs class --------------------

    static PyObject* _new_ScrollingZoomAnimationStartingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollingZoomAnimationStartingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingZoomAnimationStartingEventArgs_get_Animation(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs", L"Animation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Animation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingZoomAnimationStartingEventArgs_put_Animation(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs", L"Animation"))
        {
            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::Microsoft::UI::Composition::CompositionAnimation>(arg);

            self->obj.Animation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollingZoomAnimationStartingEventArgs_get_CenterPoint(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs", L"CenterPoint"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CenterPoint());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingZoomAnimationStartingEventArgs_get_CorrelationId(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs", L"CorrelationId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CorrelationId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingZoomAnimationStartingEventArgs_get_EndZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs", L"EndZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.EndZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ScrollingZoomAnimationStartingEventArgs_get_StartZoomFactor(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs", L"StartZoomFactor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.StartZoomFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollingZoomAnimationStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingZoomAnimationStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingZoomAnimationStartingEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollingZoomAnimationStartingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingZoomAnimationStartingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingZoomAnimationStartingEventArgs[] = {
        { "animation", reinterpret_cast<getter>(ScrollingZoomAnimationStartingEventArgs_get_Animation), reinterpret_cast<setter>(ScrollingZoomAnimationStartingEventArgs_put_Animation), nullptr, nullptr },
        { "center_point", reinterpret_cast<getter>(ScrollingZoomAnimationStartingEventArgs_get_CenterPoint), nullptr, nullptr, nullptr },
        { "correlation_id", reinterpret_cast<getter>(ScrollingZoomAnimationStartingEventArgs_get_CorrelationId), nullptr, nullptr, nullptr },
        { "end_zoom_factor", reinterpret_cast<getter>(ScrollingZoomAnimationStartingEventArgs_get_EndZoomFactor), nullptr, nullptr, nullptr },
        { "start_zoom_factor", reinterpret_cast<getter>(ScrollingZoomAnimationStartingEventArgs_get_StartZoomFactor), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingZoomAnimationStartingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingZoomAnimationStartingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingZoomAnimationStartingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingZoomAnimationStartingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingZoomAnimationStartingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollingZoomAnimationStartingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingZoomAnimationStartingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomAnimationStartingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingZoomAnimationStartingEventArgs
    };

    // ----- ScrollingZoomCompletedEventArgs class --------------------

    static PyObject* _new_ScrollingZoomCompletedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ScrollingZoomCompletedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingZoomCompletedEventArgs_get_CorrelationId(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomCompletedEventArgs", L"CorrelationId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CorrelationId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ScrollingZoomCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingZoomCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingZoomCompletedEventArgs[] = {
        { "_assign_array_", _assign_array_ScrollingZoomCompletedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingZoomCompletedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingZoomCompletedEventArgs[] = {
        { "correlation_id", reinterpret_cast<getter>(ScrollingZoomCompletedEventArgs_get_CorrelationId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingZoomCompletedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingZoomCompletedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingZoomCompletedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingZoomCompletedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingZoomCompletedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ScrollingZoomCompletedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingZoomCompletedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomCompletedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingZoomCompletedEventArgs
    };

    // ----- ScrollingZoomOptions class --------------------

    static PyObject* _new_ScrollingZoomOptions(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnimationMode>(args, 0);

                winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingAnimationMode>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ScrollingSnapPointsMode>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions instance{ param0, param1 };
                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_ScrollingZoomOptions(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ScrollingZoomOptions_get_SnapPointsMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomOptions", L"SnapPointsMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SnapPointsMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingZoomOptions_put_SnapPointsMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomOptions", L"SnapPointsMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingSnapPointsMode>(arg);

            self->obj.SnapPointsMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ScrollingZoomOptions_get_AnimationMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomOptions", L"AnimationMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AnimationMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ScrollingZoomOptions_put_AnimationMode(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ScrollingZoomOptions", L"AnimationMode"))
        {
            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::Microsoft::UI::Xaml::Controls::ScrollingAnimationMode>(arg);

            self->obj.AnimationMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_ScrollingZoomOptions(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ScrollingZoomOptions(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ScrollingZoomOptions[] = {
        { "_assign_array_", _assign_array_ScrollingZoomOptions, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ScrollingZoomOptions), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ScrollingZoomOptions[] = {
        { "snap_points_mode", reinterpret_cast<getter>(ScrollingZoomOptions_get_SnapPointsMode), reinterpret_cast<setter>(ScrollingZoomOptions_put_SnapPointsMode), nullptr, nullptr },
        { "animation_mode", reinterpret_cast<getter>(ScrollingZoomOptions_get_AnimationMode), reinterpret_cast<setter>(ScrollingZoomOptions_put_AnimationMode), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ScrollingZoomOptions[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ScrollingZoomOptions) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ScrollingZoomOptions) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ScrollingZoomOptions) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ScrollingZoomOptions) },
        { },
    };

    static PyType_Spec type_spec_ScrollingZoomOptions =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ScrollingZoomOptions",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ScrollingZoomOptions),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ScrollingZoomOptions
    };

    // ----- SectionsInViewChangedEventArgs class --------------------

    static PyObject* _new_SectionsInViewChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_SectionsInViewChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SectionsInViewChangedEventArgs_get_AddedSections(py::wrapper::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SectionsInViewChangedEventArgs", L"AddedSections"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AddedSections());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SectionsInViewChangedEventArgs_get_RemovedSections(py::wrapper::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SectionsInViewChangedEventArgs", L"RemovedSections"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RemovedSections());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SectionsInViewChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SectionsInViewChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SectionsInViewChangedEventArgs[] = {
        { "_assign_array_", _assign_array_SectionsInViewChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SectionsInViewChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SectionsInViewChangedEventArgs[] = {
        { "added_sections", reinterpret_cast<getter>(SectionsInViewChangedEventArgs_get_AddedSections), nullptr, nullptr, nullptr },
        { "removed_sections", reinterpret_cast<getter>(SectionsInViewChangedEventArgs_get_RemovedSections), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SectionsInViewChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SectionsInViewChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SectionsInViewChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SectionsInViewChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SectionsInViewChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SectionsInViewChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SectionsInViewChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SectionsInViewChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SectionsInViewChangedEventArgs
    };

    // ----- SelectionChangedEventArgs class --------------------

    static PyObject* _new_SelectionChangedEventArgs(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 == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IVector<winrt::Windows::Foundation::IInspectable>>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Collections::IVector<winrt::Windows::Foundation::IInspectable>>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::SelectionChangedEventArgs instance{ param0, param1 };
                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_SelectionChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::SelectionChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SelectionChangedEventArgs_get_AddedItems(py::wrapper::Microsoft::UI::Xaml::Controls::SelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectionChangedEventArgs", L"AddedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AddedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SelectionChangedEventArgs_get_RemovedItems(py::wrapper::Microsoft::UI::Xaml::Controls::SelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectionChangedEventArgs", L"RemovedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RemovedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SelectionChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SelectionChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SelectionChangedEventArgs[] = {
        { "_assign_array_", _assign_array_SelectionChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SelectionChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SelectionChangedEventArgs[] = {
        { "added_items", reinterpret_cast<getter>(SelectionChangedEventArgs_get_AddedItems), nullptr, nullptr, nullptr },
        { "removed_items", reinterpret_cast<getter>(SelectionChangedEventArgs_get_RemovedItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SelectionChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SelectionChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SelectionChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SelectionChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SelectionChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SelectionChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SelectionChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SelectionChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SelectionChangedEventArgs
    };

    // ----- SelectorBar class --------------------

    static PyObject* _new_SelectorBar(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::Microsoft::UI::Xaml::Controls::SelectorBar 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_SelectorBar(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBar* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SelectorBar_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBar", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SelectorBar_put_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBar* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBar", L"SelectedItem"))
        {
            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::Microsoft::UI::Xaml::Controls::SelectorBarItem>(arg);

            self->obj.SelectedItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SelectorBar_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBar* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBar", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SelectorBar_get_ItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBar", L"ItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SelectorBar::ItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SelectorBar_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBar", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SelectorBar::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SelectorBar_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SelectorBar", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SelectorBar, winrt::Microsoft::UI::Xaml::Controls::SelectorBarSelectionChangedEventArgs>>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SelectorBar_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBar* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SelectorBar", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SelectorBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SelectorBar>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SelectorBar(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SelectorBar>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SelectorBar[] = {
        { "add_selection_changed", reinterpret_cast<PyCFunction>(SelectorBar_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(SelectorBar_remove_SelectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_SelectorBar, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SelectorBar), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SelectorBar[] = {
        { "selected_item", reinterpret_cast<getter>(SelectorBar_get_SelectedItem), reinterpret_cast<setter>(SelectorBar_put_SelectedItem), nullptr, nullptr },
        { "items", reinterpret_cast<getter>(SelectorBar_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SelectorBar[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SelectorBar) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SelectorBar) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SelectorBar) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SelectorBar) },
        { },
    };

    static PyType_Spec type_spec_SelectorBar =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SelectorBar",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBar),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SelectorBar
    };

    static PyGetSetDef getset_SelectorBar_Static[] = {
        { "items_property", reinterpret_cast<getter>(SelectorBar_get_ItemsProperty), nullptr, nullptr, nullptr },
        { "selected_item_property", reinterpret_cast<getter>(SelectorBar_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SelectorBar_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SelectorBar_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SelectorBar_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SelectorBar_Static) },
        { }
    };

    static PyType_Spec type_spec_SelectorBar_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SelectorBar_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SelectorBar_Static
    };

    // ----- SelectorBarItem class --------------------

    static PyObject* _new_SelectorBarItem(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::Microsoft::UI::Xaml::Controls::SelectorBarItem 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_SelectorBarItem(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SelectorBarItem_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBarItem", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SelectorBarItem_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBarItem", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SelectorBarItem_get_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBarItem", L"Icon"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Icon());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SelectorBarItem_put_Icon(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBarItem", L"Icon"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.Icon(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SelectorBarItem_get_IconProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBarItem", L"IconProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SelectorBarItem::IconProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SelectorBarItem_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SelectorBarItem", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SelectorBarItem::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SelectorBarItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SelectorBarItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SelectorBarItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SelectorBarItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SelectorBarItem[] = {
        { "_assign_array_", _assign_array_SelectorBarItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SelectorBarItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SelectorBarItem[] = {
        { "text", reinterpret_cast<getter>(SelectorBarItem_get_Text), reinterpret_cast<setter>(SelectorBarItem_put_Text), nullptr, nullptr },
        { "icon", reinterpret_cast<getter>(SelectorBarItem_get_Icon), reinterpret_cast<setter>(SelectorBarItem_put_Icon), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SelectorBarItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SelectorBarItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SelectorBarItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SelectorBarItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SelectorBarItem) },
        { },
    };

    static PyType_Spec type_spec_SelectorBarItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SelectorBarItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SelectorBarItem
    };

    static PyGetSetDef getset_SelectorBarItem_Static[] = {
        { "icon_property", reinterpret_cast<getter>(SelectorBarItem_get_IconProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(SelectorBarItem_get_TextProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SelectorBarItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SelectorBarItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SelectorBarItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SelectorBarItem_Static) },
        { }
    };

    static PyType_Spec type_spec_SelectorBarItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SelectorBarItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SelectorBarItem_Static
    };

    // ----- SelectorBarSelectionChangedEventArgs class --------------------

    static PyObject* _new_SelectorBarSelectionChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SelectorBarSelectionChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SelectorBarSelectionChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_SelectorBarSelectionChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarSelectionChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_SelectorBarSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SelectorBarSelectionChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SelectorBarSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SelectorBarSelectionChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SelectorBarSelectionChangedEventArgs[] = {
        { "_assign_array_", _assign_array_SelectorBarSelectionChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SelectorBarSelectionChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SelectorBarSelectionChangedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_SelectorBarSelectionChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SelectorBarSelectionChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SelectorBarSelectionChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SelectorBarSelectionChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SelectorBarSelectionChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SelectorBarSelectionChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SelectorBarSelectionChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SelectorBarSelectionChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SelectorBarSelectionChangedEventArgs
    };

    // ----- SemanticZoom class --------------------

    static PyObject* _new_SemanticZoom(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::Microsoft::UI::Xaml::Controls::SemanticZoom 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_SemanticZoom(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SemanticZoom_ToggleActiveView(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ToggleActiveView", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.ToggleActiveView();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_get_ZoomedOutView(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ZoomedOutView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomedOutView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoom_put_ZoomedOutView(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ZoomedOutView"))
        {
            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::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation>(arg);

            self->obj.ZoomedOutView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoom_get_ZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ZoomedInView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ZoomedInView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoom_put_ZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ZoomedInView"))
        {
            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::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation>(arg);

            self->obj.ZoomedInView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoom_get_IsZoomedInViewActive(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"IsZoomedInViewActive"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomedInViewActive());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoom_put_IsZoomedInViewActive(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"IsZoomedInViewActive"))
        {
            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.IsZoomedInViewActive(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoom_get_IsZoomOutButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"IsZoomOutButtonEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomOutButtonEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoom_put_IsZoomOutButtonEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"IsZoomOutButtonEnabled"))
        {
            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.IsZoomOutButtonEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoom_get_CanChangeViews(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"CanChangeViews"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanChangeViews());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoom_put_CanChangeViews(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"CanChangeViews"))
        {
            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.CanChangeViews(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoom_get_CanChangeViewsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"CanChangeViewsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SemanticZoom::CanChangeViewsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_get_IsZoomOutButtonEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"IsZoomOutButtonEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SemanticZoom::IsZoomOutButtonEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_get_IsZoomedInViewActiveProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"IsZoomedInViewActiveProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SemanticZoom::IsZoomedInViewActiveProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_get_ZoomedInViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ZoomedInViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SemanticZoom::ZoomedInViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_get_ZoomedOutViewProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ZoomedOutViewProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SemanticZoom::ZoomedOutViewProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_add_ViewChangeCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ViewChangeCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventHandler>(arg);

            return py::convert(self->obj.ViewChangeCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_remove_ViewChangeCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ViewChangeCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ViewChangeCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_add_ViewChangeStarted(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ViewChangeStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventHandler>(arg);

            return py::convert(self->obj.ViewChangeStarted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SemanticZoom_remove_ViewChangeStarted(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoom", L"ViewChangeStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ViewChangeStarted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SemanticZoom(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SemanticZoom>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SemanticZoom(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SemanticZoom>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SemanticZoom[] = {
        { "toggle_active_view", reinterpret_cast<PyCFunction>(SemanticZoom_ToggleActiveView), METH_VARARGS, nullptr },
        { "add_view_change_completed", reinterpret_cast<PyCFunction>(SemanticZoom_add_ViewChangeCompleted), METH_O, nullptr },
        { "remove_view_change_completed", reinterpret_cast<PyCFunction>(SemanticZoom_remove_ViewChangeCompleted), METH_O, nullptr },
        { "add_view_change_started", reinterpret_cast<PyCFunction>(SemanticZoom_add_ViewChangeStarted), METH_O, nullptr },
        { "remove_view_change_started", reinterpret_cast<PyCFunction>(SemanticZoom_remove_ViewChangeStarted), METH_O, nullptr },
        { "_assign_array_", _assign_array_SemanticZoom, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SemanticZoom), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SemanticZoom[] = {
        { "zoomed_out_view", reinterpret_cast<getter>(SemanticZoom_get_ZoomedOutView), reinterpret_cast<setter>(SemanticZoom_put_ZoomedOutView), nullptr, nullptr },
        { "zoomed_in_view", reinterpret_cast<getter>(SemanticZoom_get_ZoomedInView), reinterpret_cast<setter>(SemanticZoom_put_ZoomedInView), nullptr, nullptr },
        { "is_zoomed_in_view_active", reinterpret_cast<getter>(SemanticZoom_get_IsZoomedInViewActive), reinterpret_cast<setter>(SemanticZoom_put_IsZoomedInViewActive), nullptr, nullptr },
        { "is_zoom_out_button_enabled", reinterpret_cast<getter>(SemanticZoom_get_IsZoomOutButtonEnabled), reinterpret_cast<setter>(SemanticZoom_put_IsZoomOutButtonEnabled), nullptr, nullptr },
        { "can_change_views", reinterpret_cast<getter>(SemanticZoom_get_CanChangeViews), reinterpret_cast<setter>(SemanticZoom_put_CanChangeViews), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SemanticZoom[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SemanticZoom) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SemanticZoom) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SemanticZoom) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SemanticZoom) },
        { },
    };

    static PyType_Spec type_spec_SemanticZoom =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SemanticZoom",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoom),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SemanticZoom
    };

    static PyGetSetDef getset_SemanticZoom_Static[] = {
        { "can_change_views_property", reinterpret_cast<getter>(SemanticZoom_get_CanChangeViewsProperty), nullptr, nullptr, nullptr },
        { "is_zoom_out_button_enabled_property", reinterpret_cast<getter>(SemanticZoom_get_IsZoomOutButtonEnabledProperty), nullptr, nullptr, nullptr },
        { "is_zoomed_in_view_active_property", reinterpret_cast<getter>(SemanticZoom_get_IsZoomedInViewActiveProperty), nullptr, nullptr, nullptr },
        { "zoomed_in_view_property", reinterpret_cast<getter>(SemanticZoom_get_ZoomedInViewProperty), nullptr, nullptr, nullptr },
        { "zoomed_out_view_property", reinterpret_cast<getter>(SemanticZoom_get_ZoomedOutViewProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SemanticZoom_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SemanticZoom_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SemanticZoom_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SemanticZoom_Static) },
        { }
    };

    static PyType_Spec type_spec_SemanticZoom_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SemanticZoom_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SemanticZoom_Static
    };

    // ----- SemanticZoomLocation class --------------------

    static PyObject* _new_SemanticZoomLocation(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::Microsoft::UI::Xaml::Controls::SemanticZoomLocation 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_SemanticZoomLocation(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomLocation* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SemanticZoomLocation_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomLocation* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomLocation", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoomLocation_put_Item(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomLocation* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomLocation", L"Item"))
        {
            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.Item(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoomLocation_get_Bounds(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomLocation* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomLocation", L"Bounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Bounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoomLocation_put_Bounds(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomLocation* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomLocation", L"Bounds"))
        {
            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::Rect>(arg);

            self->obj.Bounds(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_SemanticZoomLocation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SemanticZoomLocation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SemanticZoomLocation[] = {
        { "_assign_array_", _assign_array_SemanticZoomLocation, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SemanticZoomLocation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SemanticZoomLocation[] = {
        { "item", reinterpret_cast<getter>(SemanticZoomLocation_get_Item), reinterpret_cast<setter>(SemanticZoomLocation_put_Item), nullptr, nullptr },
        { "bounds", reinterpret_cast<getter>(SemanticZoomLocation_get_Bounds), reinterpret_cast<setter>(SemanticZoomLocation_put_Bounds), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SemanticZoomLocation[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SemanticZoomLocation) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SemanticZoomLocation) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SemanticZoomLocation) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SemanticZoomLocation) },
        { },
    };

    static PyType_Spec type_spec_SemanticZoomLocation =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SemanticZoomLocation",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomLocation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SemanticZoomLocation
    };

    // ----- SemanticZoomViewChangedEventArgs class --------------------

    static PyObject* _new_SemanticZoomViewChangedEventArgs(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::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs 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_SemanticZoomViewChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SemanticZoomViewChangedEventArgs_get_SourceItem(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs", L"SourceItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SourceItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoomViewChangedEventArgs_put_SourceItem(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs", L"SourceItem"))
        {
            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::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(arg);

            self->obj.SourceItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoomViewChangedEventArgs_get_IsSourceZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs", L"IsSourceZoomedInView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSourceZoomedInView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoomViewChangedEventArgs_put_IsSourceZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs", L"IsSourceZoomedInView"))
        {
            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.IsSourceZoomedInView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SemanticZoomViewChangedEventArgs_get_DestinationItem(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs", L"DestinationItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DestinationItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SemanticZoomViewChangedEventArgs_put_DestinationItem(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs", L"DestinationItem"))
        {
            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::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(arg);

            self->obj.DestinationItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_SemanticZoomViewChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SemanticZoomViewChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SemanticZoomViewChangedEventArgs[] = {
        { "_assign_array_", _assign_array_SemanticZoomViewChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SemanticZoomViewChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SemanticZoomViewChangedEventArgs[] = {
        { "source_item", reinterpret_cast<getter>(SemanticZoomViewChangedEventArgs_get_SourceItem), reinterpret_cast<setter>(SemanticZoomViewChangedEventArgs_put_SourceItem), nullptr, nullptr },
        { "is_source_zoomed_in_view", reinterpret_cast<getter>(SemanticZoomViewChangedEventArgs_get_IsSourceZoomedInView), reinterpret_cast<setter>(SemanticZoomViewChangedEventArgs_put_IsSourceZoomedInView), nullptr, nullptr },
        { "destination_item", reinterpret_cast<getter>(SemanticZoomViewChangedEventArgs_get_DestinationItem), reinterpret_cast<setter>(SemanticZoomViewChangedEventArgs_put_DestinationItem), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SemanticZoomViewChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SemanticZoomViewChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SemanticZoomViewChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SemanticZoomViewChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SemanticZoomViewChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SemanticZoomViewChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SemanticZoomViewChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SemanticZoomViewChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SemanticZoomViewChangedEventArgs
    };

    // ----- Slider class --------------------

    static PyObject* _new_Slider(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::Microsoft::UI::Xaml::Controls::Slider 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_Slider(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Slider_get_TickPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"TickPlacement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TickPlacement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_TickPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"TickPlacement"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::TickPlacement>(arg);

            self->obj.TickPlacement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_TickFrequency(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"TickFrequency"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TickFrequency());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_TickFrequency(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"TickFrequency"))
        {
            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<double>(arg);

            self->obj.TickFrequency(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_ThumbToolTipValueConverter(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"ThumbToolTipValueConverter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ThumbToolTipValueConverter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_ThumbToolTipValueConverter(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"ThumbToolTipValueConverter"))
        {
            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::Microsoft::UI::Xaml::Data::IValueConverter>(arg);

            self->obj.ThumbToolTipValueConverter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_StepFrequency(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"StepFrequency"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.StepFrequency());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_StepFrequency(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"StepFrequency"))
        {
            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<double>(arg);

            self->obj.StepFrequency(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_SnapsTo(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"SnapsTo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SnapsTo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_SnapsTo(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"SnapsTo"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::SliderSnapsTo>(arg);

            self->obj.SnapsTo(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_IsThumbToolTipEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IsThumbToolTipEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsThumbToolTipEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_IsThumbToolTipEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IsThumbToolTipEnabled"))
        {
            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.IsThumbToolTipEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_IsDirectionReversed(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IsDirectionReversed"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsDirectionReversed());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_IsDirectionReversed(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IsDirectionReversed"))
        {
            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.IsDirectionReversed(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_IntermediateValue(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IntermediateValue"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IntermediateValue());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_IntermediateValue(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IntermediateValue"))
        {
            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<double>(arg);

            self->obj.IntermediateValue(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Slider_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::Slider* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Slider_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_IntermediateValueProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IntermediateValueProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::IntermediateValueProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_IsDirectionReversedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IsDirectionReversedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::IsDirectionReversedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_IsThumbToolTipEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"IsThumbToolTipEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::IsThumbToolTipEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_SnapsToProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"SnapsToProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::SnapsToProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_StepFrequencyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"StepFrequencyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::StepFrequencyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_ThumbToolTipValueConverterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"ThumbToolTipValueConverterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::ThumbToolTipValueConverterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_TickFrequencyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"TickFrequencyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::TickFrequencyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Slider_get_TickPlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Slider", L"TickPlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Slider::TickPlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Slider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Slider>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Slider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Slider>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Slider[] = {
        { "_assign_array_", _assign_array_Slider, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Slider), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Slider[] = {
        { "tick_placement", reinterpret_cast<getter>(Slider_get_TickPlacement), reinterpret_cast<setter>(Slider_put_TickPlacement), nullptr, nullptr },
        { "tick_frequency", reinterpret_cast<getter>(Slider_get_TickFrequency), reinterpret_cast<setter>(Slider_put_TickFrequency), nullptr, nullptr },
        { "thumb_tool_tip_value_converter", reinterpret_cast<getter>(Slider_get_ThumbToolTipValueConverter), reinterpret_cast<setter>(Slider_put_ThumbToolTipValueConverter), nullptr, nullptr },
        { "step_frequency", reinterpret_cast<getter>(Slider_get_StepFrequency), reinterpret_cast<setter>(Slider_put_StepFrequency), nullptr, nullptr },
        { "snaps_to", reinterpret_cast<getter>(Slider_get_SnapsTo), reinterpret_cast<setter>(Slider_put_SnapsTo), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(Slider_get_Orientation), reinterpret_cast<setter>(Slider_put_Orientation), nullptr, nullptr },
        { "is_thumb_tool_tip_enabled", reinterpret_cast<getter>(Slider_get_IsThumbToolTipEnabled), reinterpret_cast<setter>(Slider_put_IsThumbToolTipEnabled), nullptr, nullptr },
        { "is_direction_reversed", reinterpret_cast<getter>(Slider_get_IsDirectionReversed), reinterpret_cast<setter>(Slider_put_IsDirectionReversed), nullptr, nullptr },
        { "intermediate_value", reinterpret_cast<getter>(Slider_get_IntermediateValue), reinterpret_cast<setter>(Slider_put_IntermediateValue), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(Slider_get_HeaderTemplate), reinterpret_cast<setter>(Slider_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(Slider_get_Header), reinterpret_cast<setter>(Slider_put_Header), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Slider[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Slider) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Slider) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Slider) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Slider) },
        { },
    };

    static PyType_Spec type_spec_Slider =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Slider",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Slider),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Slider
    };

    static PyGetSetDef getset_Slider_Static[] = {
        { "header_property", reinterpret_cast<getter>(Slider_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(Slider_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "intermediate_value_property", reinterpret_cast<getter>(Slider_get_IntermediateValueProperty), nullptr, nullptr, nullptr },
        { "is_direction_reversed_property", reinterpret_cast<getter>(Slider_get_IsDirectionReversedProperty), nullptr, nullptr, nullptr },
        { "is_thumb_tool_tip_enabled_property", reinterpret_cast<getter>(Slider_get_IsThumbToolTipEnabledProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(Slider_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "snaps_to_property", reinterpret_cast<getter>(Slider_get_SnapsToProperty), nullptr, nullptr, nullptr },
        { "step_frequency_property", reinterpret_cast<getter>(Slider_get_StepFrequencyProperty), nullptr, nullptr, nullptr },
        { "thumb_tool_tip_value_converter_property", reinterpret_cast<getter>(Slider_get_ThumbToolTipValueConverterProperty), nullptr, nullptr, nullptr },
        { "tick_frequency_property", reinterpret_cast<getter>(Slider_get_TickFrequencyProperty), nullptr, nullptr, nullptr },
        { "tick_placement_property", reinterpret_cast<getter>(Slider_get_TickPlacementProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Slider_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Slider_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Slider_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Slider_Static) },
        { }
    };

    static PyType_Spec type_spec_Slider_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Slider_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Slider_Static
    };

    // ----- SplitButton class --------------------

    static PyObject* _new_SplitButton(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::Microsoft::UI::Xaml::Controls::SplitButton 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_SplitButton(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SplitButton_get_Flyout(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"Flyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Flyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitButton_put_Flyout(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"Flyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

            self->obj.Flyout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitButton_get_CommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"CommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CommandParameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitButton_put_CommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"CommandParameter"))
        {
            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.CommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitButton_get_Command(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"Command"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Command());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitButton_put_Command(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"Command"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

            self->obj.Command(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitButton_get_CommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"CommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitButton::CommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitButton_get_CommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"CommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitButton::CommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitButton_get_FlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"FlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitButton::FlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitButton_add_Click(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"Click"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SplitButton, winrt::Microsoft::UI::Xaml::Controls::SplitButtonClickEventArgs>>(arg);

            return py::convert(self->obj.Click(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitButton_remove_Click(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitButton", L"Click"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Click(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SplitButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SplitButton>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SplitButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SplitButton>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SplitButton[] = {
        { "add_click", reinterpret_cast<PyCFunction>(SplitButton_add_Click), METH_O, nullptr },
        { "remove_click", reinterpret_cast<PyCFunction>(SplitButton_remove_Click), METH_O, nullptr },
        { "_assign_array_", _assign_array_SplitButton, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SplitButton), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SplitButton[] = {
        { "flyout", reinterpret_cast<getter>(SplitButton_get_Flyout), reinterpret_cast<setter>(SplitButton_put_Flyout), nullptr, nullptr },
        { "command_parameter", reinterpret_cast<getter>(SplitButton_get_CommandParameter), reinterpret_cast<setter>(SplitButton_put_CommandParameter), nullptr, nullptr },
        { "command", reinterpret_cast<getter>(SplitButton_get_Command), reinterpret_cast<setter>(SplitButton_put_Command), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SplitButton[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SplitButton) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SplitButton) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SplitButton) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SplitButton) },
        { },
    };

    static PyType_Spec type_spec_SplitButton =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SplitButton",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButton),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SplitButton
    };

    static PyGetSetDef getset_SplitButton_Static[] = {
        { "command_parameter_property", reinterpret_cast<getter>(SplitButton_get_CommandParameterProperty), nullptr, nullptr, nullptr },
        { "command_property", reinterpret_cast<getter>(SplitButton_get_CommandProperty), nullptr, nullptr, nullptr },
        { "flyout_property", reinterpret_cast<getter>(SplitButton_get_FlyoutProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SplitButton_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SplitButton_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SplitButton_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SplitButton_Static) },
        { }
    };

    static PyType_Spec type_spec_SplitButton_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SplitButton_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SplitButton_Static
    };

    // ----- SplitButtonClickEventArgs class --------------------

    static PyObject* _new_SplitButtonClickEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SplitButtonClickEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SplitButtonClickEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_SplitButtonClickEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButtonClickEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_SplitButtonClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SplitButtonClickEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SplitButtonClickEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SplitButtonClickEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SplitButtonClickEventArgs[] = {
        { "_assign_array_", _assign_array_SplitButtonClickEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SplitButtonClickEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SplitButtonClickEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_SplitButtonClickEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SplitButtonClickEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SplitButtonClickEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SplitButtonClickEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SplitButtonClickEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SplitButtonClickEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SplitButtonClickEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SplitButtonClickEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SplitButtonClickEventArgs
    };

    // ----- SplitView class --------------------

    static PyObject* _new_SplitView(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::Microsoft::UI::Xaml::Controls::SplitView 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_SplitView(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SplitView_get_PanePlacement(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PanePlacement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PanePlacement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_PanePlacement(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PanePlacement"))
        {
            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::Microsoft::UI::Xaml::Controls::SplitViewPanePlacement>(arg);

            self->obj.PanePlacement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_PaneBackground(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneBackground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PaneBackground());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_PaneBackground(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneBackground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.PaneBackground(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_Pane(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"Pane"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Pane());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_Pane(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"Pane"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Pane(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_OpenPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"OpenPaneLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OpenPaneLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_OpenPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"OpenPaneLength"))
        {
            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<double>(arg);

            self->obj.OpenPaneLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"LightDismissOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LightDismissOverlayMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"LightDismissOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::LightDismissOverlayMode>(arg);

            self->obj.LightDismissOverlayMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_IsPaneOpen(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"IsPaneOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsPaneOpen());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_IsPaneOpen(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"IsPaneOpen"))
        {
            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.IsPaneOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"DisplayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DisplayMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_DisplayMode(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"DisplayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::SplitViewDisplayMode>(arg);

            self->obj.DisplayMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"Content"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_CompactPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"CompactPaneLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CompactPaneLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitView_put_CompactPaneLength(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"CompactPaneLength"))
        {
            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<double>(arg);

            self->obj.CompactPaneLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SplitView_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_CompactPaneLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"CompactPaneLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::CompactPaneLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_DisplayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"DisplayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::DisplayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_IsPaneOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"IsPaneOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::IsPaneOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_LightDismissOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"LightDismissOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::LightDismissOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_OpenPaneLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"OpenPaneLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::OpenPaneLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_PaneBackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneBackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::PaneBackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_PanePlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PanePlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::PanePlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_PaneProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::PaneProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_get_TemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"TemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SplitView::TemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_add_PaneClosed(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneClosed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SplitView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PaneClosed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_remove_PaneClosed(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneClosed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneClosed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_add_PaneClosing(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneClosing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SplitView, winrt::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs>>(arg);

            return py::convert(self->obj.PaneClosing(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_remove_PaneClosing(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneClosing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneClosing(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_add_PaneOpened(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SplitView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PaneOpened(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_remove_PaneOpened(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneOpened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneOpened(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_add_PaneOpening(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SplitView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.PaneOpening(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SplitView_remove_PaneOpening(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SplitView", L"PaneOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.PaneOpening(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SplitView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SplitView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SplitView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SplitView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SplitView[] = {
        { "add_pane_closed", reinterpret_cast<PyCFunction>(SplitView_add_PaneClosed), METH_O, nullptr },
        { "remove_pane_closed", reinterpret_cast<PyCFunction>(SplitView_remove_PaneClosed), METH_O, nullptr },
        { "add_pane_closing", reinterpret_cast<PyCFunction>(SplitView_add_PaneClosing), METH_O, nullptr },
        { "remove_pane_closing", reinterpret_cast<PyCFunction>(SplitView_remove_PaneClosing), METH_O, nullptr },
        { "add_pane_opened", reinterpret_cast<PyCFunction>(SplitView_add_PaneOpened), METH_O, nullptr },
        { "remove_pane_opened", reinterpret_cast<PyCFunction>(SplitView_remove_PaneOpened), METH_O, nullptr },
        { "add_pane_opening", reinterpret_cast<PyCFunction>(SplitView_add_PaneOpening), METH_O, nullptr },
        { "remove_pane_opening", reinterpret_cast<PyCFunction>(SplitView_remove_PaneOpening), METH_O, nullptr },
        { "_assign_array_", _assign_array_SplitView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SplitView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SplitView[] = {
        { "pane_placement", reinterpret_cast<getter>(SplitView_get_PanePlacement), reinterpret_cast<setter>(SplitView_put_PanePlacement), nullptr, nullptr },
        { "pane_background", reinterpret_cast<getter>(SplitView_get_PaneBackground), reinterpret_cast<setter>(SplitView_put_PaneBackground), nullptr, nullptr },
        { "pane", reinterpret_cast<getter>(SplitView_get_Pane), reinterpret_cast<setter>(SplitView_put_Pane), nullptr, nullptr },
        { "open_pane_length", reinterpret_cast<getter>(SplitView_get_OpenPaneLength), reinterpret_cast<setter>(SplitView_put_OpenPaneLength), nullptr, nullptr },
        { "light_dismiss_overlay_mode", reinterpret_cast<getter>(SplitView_get_LightDismissOverlayMode), reinterpret_cast<setter>(SplitView_put_LightDismissOverlayMode), nullptr, nullptr },
        { "is_pane_open", reinterpret_cast<getter>(SplitView_get_IsPaneOpen), reinterpret_cast<setter>(SplitView_put_IsPaneOpen), nullptr, nullptr },
        { "display_mode", reinterpret_cast<getter>(SplitView_get_DisplayMode), reinterpret_cast<setter>(SplitView_put_DisplayMode), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(SplitView_get_Content), reinterpret_cast<setter>(SplitView_put_Content), nullptr, nullptr },
        { "compact_pane_length", reinterpret_cast<getter>(SplitView_get_CompactPaneLength), reinterpret_cast<setter>(SplitView_put_CompactPaneLength), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(SplitView_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SplitView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SplitView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SplitView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SplitView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SplitView) },
        { },
    };

    static PyType_Spec type_spec_SplitView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SplitView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SplitView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SplitView
    };

    static PyGetSetDef getset_SplitView_Static[] = {
        { "compact_pane_length_property", reinterpret_cast<getter>(SplitView_get_CompactPaneLengthProperty), nullptr, nullptr, nullptr },
        { "content_property", reinterpret_cast<getter>(SplitView_get_ContentProperty), nullptr, nullptr, nullptr },
        { "display_mode_property", reinterpret_cast<getter>(SplitView_get_DisplayModeProperty), nullptr, nullptr, nullptr },
        { "is_pane_open_property", reinterpret_cast<getter>(SplitView_get_IsPaneOpenProperty), nullptr, nullptr, nullptr },
        { "light_dismiss_overlay_mode_property", reinterpret_cast<getter>(SplitView_get_LightDismissOverlayModeProperty), nullptr, nullptr, nullptr },
        { "open_pane_length_property", reinterpret_cast<getter>(SplitView_get_OpenPaneLengthProperty), nullptr, nullptr, nullptr },
        { "pane_background_property", reinterpret_cast<getter>(SplitView_get_PaneBackgroundProperty), nullptr, nullptr, nullptr },
        { "pane_placement_property", reinterpret_cast<getter>(SplitView_get_PanePlacementProperty), nullptr, nullptr, nullptr },
        { "pane_property", reinterpret_cast<getter>(SplitView_get_PaneProperty), nullptr, nullptr, nullptr },
        { "template_settings_property", reinterpret_cast<getter>(SplitView_get_TemplateSettingsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SplitView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SplitView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SplitView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SplitView_Static) },
        { }
    };

    static PyType_Spec type_spec_SplitView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SplitView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SplitView_Static
    };

    // ----- SplitViewPaneClosingEventArgs class --------------------

    static PyObject* _new_SplitViewPaneClosingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_SplitViewPaneClosingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SplitViewPaneClosingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitViewPaneClosingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SplitViewPaneClosingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SplitViewPaneClosingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_SplitViewPaneClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SplitViewPaneClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SplitViewPaneClosingEventArgs[] = {
        { "_assign_array_", _assign_array_SplitViewPaneClosingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SplitViewPaneClosingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SplitViewPaneClosingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(SplitViewPaneClosingEventArgs_get_Cancel), reinterpret_cast<setter>(SplitViewPaneClosingEventArgs_put_Cancel), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SplitViewPaneClosingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SplitViewPaneClosingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SplitViewPaneClosingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SplitViewPaneClosingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SplitViewPaneClosingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SplitViewPaneClosingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SplitViewPaneClosingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SplitViewPaneClosingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SplitViewPaneClosingEventArgs
    };

    // ----- StackLayout class --------------------

    static PyObject* _new_StackLayout(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::Microsoft::UI::Xaml::Controls::StackLayout 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_StackLayout(py::wrapper::Microsoft::UI::Xaml::Controls::StackLayout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* StackLayout_get_Spacing(py::wrapper::Microsoft::UI::Xaml::Controls::StackLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackLayout", L"Spacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Spacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackLayout_put_Spacing(py::wrapper::Microsoft::UI::Xaml::Controls::StackLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackLayout", L"Spacing"))
        {
            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<double>(arg);

            self->obj.Spacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackLayout_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::StackLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackLayout", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackLayout_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::StackLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackLayout", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackLayout_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackLayout", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackLayout::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackLayout_get_SpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackLayout", L"SpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackLayout::SpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_StackLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::StackLayout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_StackLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::StackLayout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_StackLayout[] = {
        { "_assign_array_", _assign_array_StackLayout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_StackLayout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_StackLayout[] = {
        { "spacing", reinterpret_cast<getter>(StackLayout_get_Spacing), reinterpret_cast<setter>(StackLayout_put_Spacing), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(StackLayout_get_Orientation), reinterpret_cast<setter>(StackLayout_put_Orientation), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_StackLayout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_StackLayout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_StackLayout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_StackLayout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_StackLayout) },
        { },
    };

    static PyType_Spec type_spec_StackLayout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.StackLayout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::StackLayout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_StackLayout
    };

    static PyGetSetDef getset_StackLayout_Static[] = {
        { "orientation_property", reinterpret_cast<getter>(StackLayout_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "spacing_property", reinterpret_cast<getter>(StackLayout_get_SpacingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_StackLayout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_StackLayout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_StackLayout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_StackLayout_Static) },
        { }
    };

    static PyType_Spec type_spec_StackLayout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.StackLayout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_StackLayout_Static
    };

    // ----- StackPanel class --------------------

    static PyObject* _new_StackPanel(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::Microsoft::UI::Xaml::Controls::StackPanel 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_StackPanel(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* StackPanel_GetInsertionIndexes(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"GetInsertionIndexes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Point>(args, 0);
                int32_t param1 {  };
                int32_t param2 {  };

                self->obj.GetInsertionIndexes(param0, param1, param2);

                py::pyobj_handle out1{ py::convert(param1) };
                if (!out1)
                {
                    return nullptr;
                }
                py::pyobj_handle out2{ py::convert(param2) };
                if (!out2)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out1.get(), out2.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* StackPanel_GetIrregularSnapPoints(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"GetIrregularSnapPoints", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Orientation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::SnapPointsAlignment>(args, 1);

                return py::convert(self->obj.GetIrregularSnapPoints(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* StackPanel_GetRegularSnapPoints(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"GetRegularSnapPoints", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Orientation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::SnapPointsAlignment>(args, 1);
                float param2 {  };

                auto return_value = self->obj.GetRegularSnapPoints(param0, param1, param2);

                py::pyobj_handle out_return_value{ py::convert(return_value) };
                if (!out_return_value)
                {
                    return nullptr;
                }
                py::pyobj_handle out2{ py::convert(param2) };
                if (!out2)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out_return_value.get(), out2.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_Spacing(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"Spacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Spacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_Spacing(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"Spacing"))
        {
            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<double>(arg);

            self->obj.Spacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Padding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.Padding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"CornerRadius"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CornerRadius());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_CornerRadius(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"CornerRadius"))
        {
            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::Microsoft::UI::Xaml::CornerRadius>(arg);

            self->obj.CornerRadius(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BorderThickness"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BorderThickness());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_BorderThickness(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BorderThickness"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.BorderThickness(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BorderBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BorderBrush());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_BorderBrush(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BorderBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.BorderBrush(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BackgroundSizing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BackgroundSizing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_BackgroundSizing(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BackgroundSizing"))
        {
            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::Microsoft::UI::Xaml::Controls::BackgroundSizing>(arg);

            self->obj.BackgroundSizing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_AreScrollSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"AreScrollSnapPointsRegular"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreScrollSnapPointsRegular());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int StackPanel_put_AreScrollSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"AreScrollSnapPointsRegular"))
        {
            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.AreScrollSnapPointsRegular(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* StackPanel_get_AreHorizontalSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"AreHorizontalSnapPointsRegular"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreHorizontalSnapPointsRegular());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_AreVerticalSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"AreVerticalSnapPointsRegular"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreVerticalSnapPointsRegular());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_AreScrollSnapPointsRegularProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"AreScrollSnapPointsRegularProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::AreScrollSnapPointsRegularProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_BackgroundSizingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BackgroundSizingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::BackgroundSizingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_BorderBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BorderBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::BorderBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_BorderThicknessProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"BorderThicknessProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::BorderThicknessProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_CornerRadiusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"CornerRadiusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::CornerRadiusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_get_SpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"SpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::StackPanel::SpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_add_HorizontalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"HorizontalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.HorizontalSnapPointsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_remove_HorizontalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"HorizontalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.HorizontalSnapPointsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_add_VerticalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"VerticalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.VerticalSnapPointsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* StackPanel_remove_VerticalSnapPointsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.StackPanel", L"VerticalSnapPointsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.VerticalSnapPointsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_StackPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::StackPanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_StackPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::StackPanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_StackPanel[] = {
        { "get_insertion_indexes", reinterpret_cast<PyCFunction>(StackPanel_GetInsertionIndexes), METH_VARARGS, nullptr },
        { "get_irregular_snap_points", reinterpret_cast<PyCFunction>(StackPanel_GetIrregularSnapPoints), METH_VARARGS, nullptr },
        { "get_regular_snap_points", reinterpret_cast<PyCFunction>(StackPanel_GetRegularSnapPoints), METH_VARARGS, nullptr },
        { "add_horizontal_snap_points_changed", reinterpret_cast<PyCFunction>(StackPanel_add_HorizontalSnapPointsChanged), METH_O, nullptr },
        { "remove_horizontal_snap_points_changed", reinterpret_cast<PyCFunction>(StackPanel_remove_HorizontalSnapPointsChanged), METH_O, nullptr },
        { "add_vertical_snap_points_changed", reinterpret_cast<PyCFunction>(StackPanel_add_VerticalSnapPointsChanged), METH_O, nullptr },
        { "remove_vertical_snap_points_changed", reinterpret_cast<PyCFunction>(StackPanel_remove_VerticalSnapPointsChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_StackPanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_StackPanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_StackPanel[] = {
        { "spacing", reinterpret_cast<getter>(StackPanel_get_Spacing), reinterpret_cast<setter>(StackPanel_put_Spacing), nullptr, nullptr },
        { "padding", reinterpret_cast<getter>(StackPanel_get_Padding), reinterpret_cast<setter>(StackPanel_put_Padding), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(StackPanel_get_Orientation), reinterpret_cast<setter>(StackPanel_put_Orientation), nullptr, nullptr },
        { "corner_radius", reinterpret_cast<getter>(StackPanel_get_CornerRadius), reinterpret_cast<setter>(StackPanel_put_CornerRadius), nullptr, nullptr },
        { "border_thickness", reinterpret_cast<getter>(StackPanel_get_BorderThickness), reinterpret_cast<setter>(StackPanel_put_BorderThickness), nullptr, nullptr },
        { "border_brush", reinterpret_cast<getter>(StackPanel_get_BorderBrush), reinterpret_cast<setter>(StackPanel_put_BorderBrush), nullptr, nullptr },
        { "background_sizing", reinterpret_cast<getter>(StackPanel_get_BackgroundSizing), reinterpret_cast<setter>(StackPanel_put_BackgroundSizing), nullptr, nullptr },
        { "are_scroll_snap_points_regular", reinterpret_cast<getter>(StackPanel_get_AreScrollSnapPointsRegular), reinterpret_cast<setter>(StackPanel_put_AreScrollSnapPointsRegular), nullptr, nullptr },
        { "are_horizontal_snap_points_regular", reinterpret_cast<getter>(StackPanel_get_AreHorizontalSnapPointsRegular), nullptr, nullptr, nullptr },
        { "are_vertical_snap_points_regular", reinterpret_cast<getter>(StackPanel_get_AreVerticalSnapPointsRegular), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_StackPanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_StackPanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_StackPanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_StackPanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_StackPanel) },
        { },
    };

    static PyType_Spec type_spec_StackPanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.StackPanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::StackPanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_StackPanel
    };

    static PyGetSetDef getset_StackPanel_Static[] = {
        { "are_scroll_snap_points_regular_property", reinterpret_cast<getter>(StackPanel_get_AreScrollSnapPointsRegularProperty), nullptr, nullptr, nullptr },
        { "background_sizing_property", reinterpret_cast<getter>(StackPanel_get_BackgroundSizingProperty), nullptr, nullptr, nullptr },
        { "border_brush_property", reinterpret_cast<getter>(StackPanel_get_BorderBrushProperty), nullptr, nullptr, nullptr },
        { "border_thickness_property", reinterpret_cast<getter>(StackPanel_get_BorderThicknessProperty), nullptr, nullptr, nullptr },
        { "corner_radius_property", reinterpret_cast<getter>(StackPanel_get_CornerRadiusProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(StackPanel_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(StackPanel_get_PaddingProperty), nullptr, nullptr, nullptr },
        { "spacing_property", reinterpret_cast<getter>(StackPanel_get_SpacingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_StackPanel_Static[] = {
        { }
    };

    static PyType_Slot type_slots_StackPanel_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_StackPanel_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_StackPanel_Static) },
        { }
    };

    static PyType_Spec type_spec_StackPanel_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.StackPanel_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_StackPanel_Static
    };

    // ----- StyleSelector class --------------------

    static PyObject* _new_StyleSelector(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::Microsoft::UI::Xaml::Controls::StyleSelector 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_StyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::StyleSelector* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* StyleSelector_SelectStyle(py::wrapper::Microsoft::UI::Xaml::Controls::StyleSelector* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.StyleSelector", L"SelectStyle", 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::Microsoft::UI::Xaml::DependencyObject>(args, 1);

                return py::convert(self->obj.SelectStyle(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_StyleSelector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::StyleSelector>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_StyleSelector(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::StyleSelector>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_StyleSelector[] = {
        { "select_style", reinterpret_cast<PyCFunction>(StyleSelector_SelectStyle), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_StyleSelector, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_StyleSelector), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_StyleSelector[] = {
        { }
    };

    static PyType_Slot _type_slots_StyleSelector[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_StyleSelector) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_StyleSelector) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_StyleSelector) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_StyleSelector) },
        { },
    };

    static PyType_Spec type_spec_StyleSelector =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.StyleSelector",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::StyleSelector),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_StyleSelector
    };

    // ----- SwapChainBackgroundPanel class --------------------

    static PyObject* _new_SwapChainBackgroundPanel(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::Microsoft::UI::Xaml::Controls::SwapChainBackgroundPanel 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_SwapChainBackgroundPanel(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainBackgroundPanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_SwapChainBackgroundPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SwapChainBackgroundPanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SwapChainBackgroundPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SwapChainBackgroundPanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SwapChainBackgroundPanel[] = {
        { "_assign_array_", _assign_array_SwapChainBackgroundPanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SwapChainBackgroundPanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SwapChainBackgroundPanel[] = {
        { }
    };

    static PyType_Slot _type_slots_SwapChainBackgroundPanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SwapChainBackgroundPanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SwapChainBackgroundPanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SwapChainBackgroundPanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SwapChainBackgroundPanel) },
        { },
    };

    static PyType_Spec type_spec_SwapChainBackgroundPanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwapChainBackgroundPanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainBackgroundPanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SwapChainBackgroundPanel
    };

    // ----- SwapChainPanel class --------------------

    static PyObject* _new_SwapChainPanel(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::Microsoft::UI::Xaml::Controls::SwapChainPanel 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_SwapChainPanel(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainPanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SwapChainPanel_CreateCoreIndependentInputSource(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainPanel* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwapChainPanel", L"CreateCoreIndependentInputSource", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Input::InputPointerSourceDeviceKinds>(args, 0);

                return py::convert(self->obj.CreateCoreIndependentInputSource(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwapChainPanel_get_CompositionScaleX(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwapChainPanel", L"CompositionScaleX"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CompositionScaleX());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwapChainPanel_get_CompositionScaleY(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwapChainPanel", L"CompositionScaleY"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CompositionScaleY());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwapChainPanel_get_CompositionScaleXProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwapChainPanel", L"CompositionScaleXProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwapChainPanel::CompositionScaleXProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwapChainPanel_get_CompositionScaleYProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwapChainPanel", L"CompositionScaleYProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwapChainPanel::CompositionScaleYProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwapChainPanel_add_CompositionScaleChanged(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SwapChainPanel", L"CompositionScaleChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SwapChainPanel, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.CompositionScaleChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwapChainPanel_remove_CompositionScaleChanged(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SwapChainPanel", L"CompositionScaleChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CompositionScaleChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SwapChainPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SwapChainPanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SwapChainPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SwapChainPanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SwapChainPanel[] = {
        { "create_core_independent_input_source", reinterpret_cast<PyCFunction>(SwapChainPanel_CreateCoreIndependentInputSource), METH_VARARGS, nullptr },
        { "add_composition_scale_changed", reinterpret_cast<PyCFunction>(SwapChainPanel_add_CompositionScaleChanged), METH_O, nullptr },
        { "remove_composition_scale_changed", reinterpret_cast<PyCFunction>(SwapChainPanel_remove_CompositionScaleChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_SwapChainPanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SwapChainPanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SwapChainPanel[] = {
        { "composition_scale_x", reinterpret_cast<getter>(SwapChainPanel_get_CompositionScaleX), nullptr, nullptr, nullptr },
        { "composition_scale_y", reinterpret_cast<getter>(SwapChainPanel_get_CompositionScaleY), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SwapChainPanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SwapChainPanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SwapChainPanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SwapChainPanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SwapChainPanel) },
        { },
    };

    static PyType_Spec type_spec_SwapChainPanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwapChainPanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SwapChainPanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SwapChainPanel
    };

    static PyGetSetDef getset_SwapChainPanel_Static[] = {
        { "composition_scale_x_property", reinterpret_cast<getter>(SwapChainPanel_get_CompositionScaleXProperty), nullptr, nullptr, nullptr },
        { "composition_scale_y_property", reinterpret_cast<getter>(SwapChainPanel_get_CompositionScaleYProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SwapChainPanel_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SwapChainPanel_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SwapChainPanel_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SwapChainPanel_Static) },
        { }
    };

    static PyType_Spec type_spec_SwapChainPanel_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwapChainPanel_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SwapChainPanel_Static
    };

    // ----- SwipeControl class --------------------

    static PyObject* _new_SwipeControl(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::Microsoft::UI::Xaml::Controls::SwipeControl 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_SwipeControl(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SwipeControl_Close(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeControl_get_TopItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"TopItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeControl_put_TopItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"TopItems"))
        {
            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::Microsoft::UI::Xaml::Controls::SwipeItems>(arg);

            self->obj.TopItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeControl_get_RightItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"RightItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RightItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeControl_put_RightItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"RightItems"))
        {
            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::Microsoft::UI::Xaml::Controls::SwipeItems>(arg);

            self->obj.RightItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeControl_get_LeftItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"LeftItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LeftItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeControl_put_LeftItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"LeftItems"))
        {
            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::Microsoft::UI::Xaml::Controls::SwipeItems>(arg);

            self->obj.LeftItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeControl_get_BottomItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"BottomItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BottomItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeControl_put_BottomItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"BottomItems"))
        {
            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::Microsoft::UI::Xaml::Controls::SwipeItems>(arg);

            self->obj.BottomItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeControl_get_BottomItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"BottomItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeControl::BottomItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeControl_get_LeftItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"LeftItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeControl::LeftItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeControl_get_RightItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"RightItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeControl::RightItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeControl_get_TopItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeControl", L"TopItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeControl::TopItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SwipeControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SwipeControl>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SwipeControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SwipeControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SwipeControl[] = {
        { "close", reinterpret_cast<PyCFunction>(SwipeControl_Close), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_SwipeControl, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SwipeControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SwipeControl[] = {
        { "top_items", reinterpret_cast<getter>(SwipeControl_get_TopItems), reinterpret_cast<setter>(SwipeControl_put_TopItems), nullptr, nullptr },
        { "right_items", reinterpret_cast<getter>(SwipeControl_get_RightItems), reinterpret_cast<setter>(SwipeControl_put_RightItems), nullptr, nullptr },
        { "left_items", reinterpret_cast<getter>(SwipeControl_get_LeftItems), reinterpret_cast<setter>(SwipeControl_put_LeftItems), nullptr, nullptr },
        { "bottom_items", reinterpret_cast<getter>(SwipeControl_get_BottomItems), reinterpret_cast<setter>(SwipeControl_put_BottomItems), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SwipeControl[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SwipeControl) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SwipeControl) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SwipeControl) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SwipeControl) },
        { },
    };

    static PyType_Spec type_spec_SwipeControl =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwipeControl",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SwipeControl
    };

    static PyGetSetDef getset_SwipeControl_Static[] = {
        { "bottom_items_property", reinterpret_cast<getter>(SwipeControl_get_BottomItemsProperty), nullptr, nullptr, nullptr },
        { "left_items_property", reinterpret_cast<getter>(SwipeControl_get_LeftItemsProperty), nullptr, nullptr, nullptr },
        { "right_items_property", reinterpret_cast<getter>(SwipeControl_get_RightItemsProperty), nullptr, nullptr, nullptr },
        { "top_items_property", reinterpret_cast<getter>(SwipeControl_get_TopItemsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SwipeControl_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SwipeControl_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SwipeControl_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SwipeControl_Static) },
        { }
    };

    static PyType_Spec type_spec_SwipeControl_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwipeControl_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SwipeControl_Static
    };

    // ----- SwipeItem class --------------------

    static PyObject* _new_SwipeItem(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::Microsoft::UI::Xaml::Controls::SwipeItem 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_SwipeItem(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SwipeItem_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItem_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItem_get_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"IconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItem_put_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"IconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

            self->obj.IconSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItem_get_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Foreground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Foreground());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItem_put_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Foreground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Foreground(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItem_get_CommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"CommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CommandParameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItem_put_CommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"CommandParameter"))
        {
            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.CommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItem_get_Command(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Command"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Command());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItem_put_Command(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Command"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

            self->obj.Command(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItem_get_BehaviorOnInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"BehaviorOnInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BehaviorOnInvoked());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItem_put_BehaviorOnInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"BehaviorOnInvoked"))
        {
            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::Microsoft::UI::Xaml::Controls::SwipeBehaviorOnInvoked>(arg);

            self->obj.BehaviorOnInvoked(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItem_get_Background(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Background"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Background());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItem_put_Background(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Background"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Background(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItem_get_BackgroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"BackgroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItem::BackgroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_get_BehaviorOnInvokedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"BehaviorOnInvokedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItem::BehaviorOnInvokedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_get_CommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"CommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItem::CommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_get_CommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"CommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItem::CommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_get_ForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"ForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItem::ForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_get_IconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"IconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItem::IconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItem::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_add_Invoked(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Invoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::SwipeItem, winrt::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs>>(arg);

            return py::convert(self->obj.Invoked(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SwipeItem_remove_Invoked(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.SwipeItem", L"Invoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Invoked(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SwipeItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SwipeItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SwipeItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SwipeItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SwipeItem[] = {
        { "add_invoked", reinterpret_cast<PyCFunction>(SwipeItem_add_Invoked), METH_O, nullptr },
        { "remove_invoked", reinterpret_cast<PyCFunction>(SwipeItem_remove_Invoked), METH_O, nullptr },
        { "_assign_array_", _assign_array_SwipeItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SwipeItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SwipeItem[] = {
        { "text", reinterpret_cast<getter>(SwipeItem_get_Text), reinterpret_cast<setter>(SwipeItem_put_Text), nullptr, nullptr },
        { "icon_source", reinterpret_cast<getter>(SwipeItem_get_IconSource), reinterpret_cast<setter>(SwipeItem_put_IconSource), nullptr, nullptr },
        { "foreground", reinterpret_cast<getter>(SwipeItem_get_Foreground), reinterpret_cast<setter>(SwipeItem_put_Foreground), nullptr, nullptr },
        { "command_parameter", reinterpret_cast<getter>(SwipeItem_get_CommandParameter), reinterpret_cast<setter>(SwipeItem_put_CommandParameter), nullptr, nullptr },
        { "command", reinterpret_cast<getter>(SwipeItem_get_Command), reinterpret_cast<setter>(SwipeItem_put_Command), nullptr, nullptr },
        { "behavior_on_invoked", reinterpret_cast<getter>(SwipeItem_get_BehaviorOnInvoked), reinterpret_cast<setter>(SwipeItem_put_BehaviorOnInvoked), nullptr, nullptr },
        { "background", reinterpret_cast<getter>(SwipeItem_get_Background), reinterpret_cast<setter>(SwipeItem_put_Background), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SwipeItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SwipeItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SwipeItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SwipeItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SwipeItem) },
        { },
    };

    static PyType_Spec type_spec_SwipeItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwipeItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SwipeItem
    };

    static PyGetSetDef getset_SwipeItem_Static[] = {
        { "background_property", reinterpret_cast<getter>(SwipeItem_get_BackgroundProperty), nullptr, nullptr, nullptr },
        { "behavior_on_invoked_property", reinterpret_cast<getter>(SwipeItem_get_BehaviorOnInvokedProperty), nullptr, nullptr, nullptr },
        { "command_parameter_property", reinterpret_cast<getter>(SwipeItem_get_CommandParameterProperty), nullptr, nullptr, nullptr },
        { "command_property", reinterpret_cast<getter>(SwipeItem_get_CommandProperty), nullptr, nullptr, nullptr },
        { "foreground_property", reinterpret_cast<getter>(SwipeItem_get_ForegroundProperty), nullptr, nullptr, nullptr },
        { "icon_source_property", reinterpret_cast<getter>(SwipeItem_get_IconSourceProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(SwipeItem_get_TextProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SwipeItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SwipeItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SwipeItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SwipeItem_Static) },
        { }
    };

    static PyType_Spec type_spec_SwipeItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwipeItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SwipeItem_Static
    };

    // ----- SwipeItemInvokedEventArgs class --------------------

    static PyObject* _new_SwipeItemInvokedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_SwipeItemInvokedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SwipeItemInvokedEventArgs_get_SwipeControl(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItemInvokedEventArgs", L"SwipeControl"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SwipeControl());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SwipeItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SwipeItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SwipeItemInvokedEventArgs[] = {
        { "_assign_array_", _assign_array_SwipeItemInvokedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SwipeItemInvokedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SwipeItemInvokedEventArgs[] = {
        { "swipe_control", reinterpret_cast<getter>(SwipeItemInvokedEventArgs_get_SwipeControl), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SwipeItemInvokedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SwipeItemInvokedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SwipeItemInvokedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SwipeItemInvokedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SwipeItemInvokedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_SwipeItemInvokedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwipeItemInvokedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItemInvokedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SwipeItemInvokedEventArgs
    };

    // ----- SwipeItems class --------------------

    static PyObject* _new_SwipeItems(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::Microsoft::UI::Xaml::Controls::SwipeItems 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_SwipeItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SwipeItems_Append(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"Append", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SwipeItem>(args, 0);

                self->obj.Append(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_Clear(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"Clear", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Clear();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_First(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", 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* SwipeItems_GetAt(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", 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* SwipeItems_GetMany(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", 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::Microsoft::UI::Xaml::Controls::SwipeItem, 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* SwipeItems_GetView(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"GetView", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetView());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_IndexOf(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SwipeItem>(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* SwipeItems_InsertAt(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"InsertAt", 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::Microsoft::UI::Xaml::Controls::SwipeItem>(args, 1);

                self->obj.InsertAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_RemoveAt(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"RemoveAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);

                self->obj.RemoveAt(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_RemoveAtEnd(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"RemoveAtEnd", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RemoveAtEnd();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_ReplaceAll(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"ReplaceAll", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<winrt::Microsoft::UI::Xaml::Controls::SwipeItem, false>>(args, 0);

                self->obj.ReplaceAll(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_SetAt(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"SetAt", 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::Microsoft::UI::Xaml::Controls::SwipeItem>(args, 1);

                self->obj.SetAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SwipeItems_get_Mode(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"Mode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Mode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SwipeItems_put_Mode(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"Mode"))
        {
            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::Microsoft::UI::Xaml::Controls::SwipeMode>(arg);

            self->obj.Mode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SwipeItems_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", 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* SwipeItems_get_ModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SwipeItems", L"ModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SwipeItems::ModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SwipeItems(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SwipeItems>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SwipeItems(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SwipeItems>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_SwipeItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_SwipeItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_SwipeItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* 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_SwipeItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* 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_SwipeItems(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::Microsoft::UI::Xaml::Controls::SwipeItem> items(static_cast<uint32_t>(length), empty_instance<winrt::Microsoft::UI::Xaml::Controls::SwipeItem>::get());

            auto count = self->obj.GetMany(static_cast<uint32_t>(start), items);

            if (count != static_cast<uint32_t>(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 int _seq_assign_SwipeItems(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems* self, Py_ssize_t i, PyObject* value) noexcept
    {
        try
        {
            if (value == nullptr) { self->obj.RemoveAt(static_cast<uint32_t>(i)); }
            else { self->obj.SetAt(static_cast<uint32_t>(i), py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SwipeItem>(value)); }
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyMethodDef _methods_SwipeItems[] = {
        { "append", reinterpret_cast<PyCFunction>(SwipeItems_Append), METH_VARARGS, nullptr },
        { "clear", reinterpret_cast<PyCFunction>(SwipeItems_Clear), METH_VARARGS, nullptr },
        { "first", reinterpret_cast<PyCFunction>(SwipeItems_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(SwipeItems_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(SwipeItems_GetMany), METH_VARARGS, nullptr },
        { "get_view", reinterpret_cast<PyCFunction>(SwipeItems_GetView), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(SwipeItems_IndexOf), METH_VARARGS, nullptr },
        { "insert_at", reinterpret_cast<PyCFunction>(SwipeItems_InsertAt), METH_VARARGS, nullptr },
        { "remove_at", reinterpret_cast<PyCFunction>(SwipeItems_RemoveAt), METH_VARARGS, nullptr },
        { "remove_at_end", reinterpret_cast<PyCFunction>(SwipeItems_RemoveAtEnd), METH_VARARGS, nullptr },
        { "replace_all", reinterpret_cast<PyCFunction>(SwipeItems_ReplaceAll), METH_VARARGS, nullptr },
        { "set_at", reinterpret_cast<PyCFunction>(SwipeItems_SetAt), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_SwipeItems, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SwipeItems), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SwipeItems[] = {
        { "mode", reinterpret_cast<getter>(SwipeItems_get_Mode), reinterpret_cast<setter>(SwipeItems_put_Mode), nullptr, nullptr },
        { "size", reinterpret_cast<getter>(SwipeItems_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SwipeItems[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SwipeItems) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SwipeItems) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SwipeItems) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SwipeItems) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_SwipeItems) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_SwipeItems) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_SwipeItems) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_SwipeItems) },
        { Py_sq_ass_item, reinterpret_cast<void*>(_seq_assign_SwipeItems) },
        { },
    };

    static PyType_Spec type_spec_SwipeItems =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwipeItems",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SwipeItems),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SwipeItems
    };

    static PyGetSetDef getset_SwipeItems_Static[] = {
        { "mode_property", reinterpret_cast<getter>(SwipeItems_get_ModeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SwipeItems_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SwipeItems_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SwipeItems_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SwipeItems_Static) },
        { }
    };

    static PyType_Spec type_spec_SwipeItems_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SwipeItems_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SwipeItems_Static
    };

    // ----- SymbolIcon class --------------------

    static PyObject* _new_SymbolIcon(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 == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Symbol>(args, 0);

                winrt::Microsoft::UI::Xaml::Controls::SymbolIcon instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Microsoft::UI::Xaml::Controls::SymbolIcon 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_SymbolIcon(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIcon* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SymbolIcon_get_Symbol(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIcon* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SymbolIcon", L"Symbol"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Symbol());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SymbolIcon_put_Symbol(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIcon* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SymbolIcon", L"Symbol"))
        {
            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::Microsoft::UI::Xaml::Controls::Symbol>(arg);

            self->obj.Symbol(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SymbolIcon_get_SymbolProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SymbolIcon", L"SymbolProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SymbolIcon::SymbolProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SymbolIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SymbolIcon>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SymbolIcon(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SymbolIcon>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SymbolIcon[] = {
        { "_assign_array_", _assign_array_SymbolIcon, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SymbolIcon), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SymbolIcon[] = {
        { "symbol", reinterpret_cast<getter>(SymbolIcon_get_Symbol), reinterpret_cast<setter>(SymbolIcon_put_Symbol), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SymbolIcon[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SymbolIcon) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SymbolIcon) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SymbolIcon) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SymbolIcon) },
        { },
    };

    static PyType_Spec type_spec_SymbolIcon =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SymbolIcon",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIcon),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SymbolIcon
    };

    static PyGetSetDef getset_SymbolIcon_Static[] = {
        { "symbol_property", reinterpret_cast<getter>(SymbolIcon_get_SymbolProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SymbolIcon_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SymbolIcon_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SymbolIcon_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SymbolIcon_Static) },
        { }
    };

    static PyType_Spec type_spec_SymbolIcon_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SymbolIcon_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SymbolIcon_Static
    };

    // ----- SymbolIconSource class --------------------

    static PyObject* _new_SymbolIconSource(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::Microsoft::UI::Xaml::Controls::SymbolIconSource 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_SymbolIconSource(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIconSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* SymbolIconSource_get_Symbol(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIconSource* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SymbolIconSource", L"Symbol"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Symbol());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int SymbolIconSource_put_Symbol(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIconSource* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SymbolIconSource", L"Symbol"))
        {
            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::Microsoft::UI::Xaml::Controls::Symbol>(arg);

            self->obj.Symbol(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* SymbolIconSource_get_SymbolProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.SymbolIconSource", L"SymbolProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::SymbolIconSource::SymbolProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_SymbolIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::SymbolIconSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_SymbolIconSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::SymbolIconSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SymbolIconSource[] = {
        { "_assign_array_", _assign_array_SymbolIconSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_SymbolIconSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SymbolIconSource[] = {
        { "symbol", reinterpret_cast<getter>(SymbolIconSource_get_Symbol), reinterpret_cast<setter>(SymbolIconSource_put_Symbol), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SymbolIconSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_SymbolIconSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_SymbolIconSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_SymbolIconSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_SymbolIconSource) },
        { },
    };

    static PyType_Spec type_spec_SymbolIconSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SymbolIconSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::SymbolIconSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SymbolIconSource
    };

    static PyGetSetDef getset_SymbolIconSource_Static[] = {
        { "symbol_property", reinterpret_cast<getter>(SymbolIconSource_get_SymbolProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_SymbolIconSource_Static[] = {
        { }
    };

    static PyType_Slot type_slots_SymbolIconSource_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_SymbolIconSource_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_SymbolIconSource_Static) },
        { }
    };

    static PyType_Spec type_spec_SymbolIconSource_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.SymbolIconSource_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_SymbolIconSource_Static
    };

    // ----- TabView class --------------------

    static PyObject* _new_TabView(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::Microsoft::UI::Xaml::Controls::TabView 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_TabView(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TabView_ContainerFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"ContainerFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.ContainerFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TabView_ContainerFromItem(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"ContainerFromItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.ContainerFromItem(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabWidthMode(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabWidthMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabWidthMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabWidthMode(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabWidthMode"))
        {
            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::Microsoft::UI::Xaml::Controls::TabViewWidthMode>(arg);

            self->obj.TabWidthMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabStripHeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripHeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabStripHeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabStripHeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripHeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.TabStripHeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabStripHeader(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripHeader"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabStripHeader());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabStripHeader(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripHeader"))
        {
            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.TabStripHeader(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabStripFooterTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripFooterTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabStripFooterTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabStripFooterTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripFooterTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.TabStripFooterTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabStripFooter(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripFooter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabStripFooter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabStripFooter(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripFooter"))
        {
            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.TabStripFooter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemsSource"))
        {
            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.TabItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabItemTemplateSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

            self->obj.TabItemTemplateSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_TabItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.TabItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectedItem"))
        {
            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.SelectedItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectedIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_SelectedIndex(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectedIndex"))
        {
            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<int32_t>(arg);

            self->obj.SelectedIndex(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_IsAddTabButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"IsAddTabButtonVisible"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsAddTabButtonVisible());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_IsAddTabButtonVisible(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"IsAddTabButtonVisible"))
        {
            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.IsAddTabButtonVisible(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_CloseButtonOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CloseButtonOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonOverlayMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_CloseButtonOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CloseButtonOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::TabViewCloseButtonOverlayMode>(arg);

            self->obj.CloseButtonOverlayMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_CanReorderTabs(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CanReorderTabs"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanReorderTabs());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_CanReorderTabs(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CanReorderTabs"))
        {
            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.CanReorderTabs(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_CanDragTabs(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CanDragTabs"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanDragTabs());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_CanDragTabs(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CanDragTabs"))
        {
            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.CanDragTabs(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_AllowDropTabs(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AllowDropTabs"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AllowDropTabs());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_AllowDropTabs(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AllowDropTabs"))
        {
            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.AllowDropTabs(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_AddTabButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonCommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AddTabButtonCommandParameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_AddTabButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonCommandParameter"))
        {
            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.AddTabButtonCommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_AddTabButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonCommand"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AddTabButtonCommand());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabView_put_AddTabButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonCommand"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

            self->obj.AddTabButtonCommand(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabView_get_TabItems(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_AddTabButtonCommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonCommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::AddTabButtonCommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_AddTabButtonCommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonCommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::AddTabButtonCommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_AllowDropTabsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AllowDropTabsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::AllowDropTabsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_CanDragTabsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CanDragTabsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::CanDragTabsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_CanReorderTabsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CanReorderTabsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::CanReorderTabsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_CloseButtonOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"CloseButtonOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::CloseButtonOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_IsAddTabButtonVisibleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"IsAddTabButtonVisibleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::IsAddTabButtonVisibleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_SelectedIndexProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectedIndexProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::SelectedIndexProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabItemTemplateSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemTemplateSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabItemTemplateSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabStripFooterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripFooterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabStripFooterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabStripFooterTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripFooterTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabStripFooterTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabStripHeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripHeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabStripHeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabStripHeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripHeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabStripHeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_get_TabWidthModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabWidthModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabView::TabWidthModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_AddTabButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TabView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.AddTabButtonClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_AddTabButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"AddTabButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.AddTabButtonClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SelectionChangedEventHandler>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_TabCloseRequested(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabCloseRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TabView, winrt::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs>>(arg);

            return py::convert(self->obj.TabCloseRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_TabCloseRequested(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabCloseRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TabCloseRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_TabDragCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabDragCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TabView, winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs>>(arg);

            return py::convert(self->obj.TabDragCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_TabDragCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabDragCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TabDragCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_TabDragStarting(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabDragStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TabView, winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs>>(arg);

            return py::convert(self->obj.TabDragStarting(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_TabDragStarting(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabDragStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TabDragStarting(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_TabDroppedOutside(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabDroppedOutside"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TabView, winrt::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs>>(arg);

            return py::convert(self->obj.TabDroppedOutside(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_TabDroppedOutside(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabDroppedOutside"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TabDroppedOutside(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_TabItemsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TabView, winrt::Windows::Foundation::Collections::IVectorChangedEventArgs>>(arg);

            return py::convert(self->obj.TabItemsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_TabItemsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabItemsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TabItemsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_TabStripDragOver(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripDragOver"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DragEventHandler>(arg);

            return py::convert(self->obj.TabStripDragOver(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_TabStripDragOver(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripDragOver"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TabStripDragOver(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_add_TabStripDrop(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripDrop"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DragEventHandler>(arg);

            return py::convert(self->obj.TabStripDrop(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabView_remove_TabStripDrop(py::wrapper::Microsoft::UI::Xaml::Controls::TabView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabView", L"TabStripDrop"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TabStripDrop(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TabView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TabView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TabView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TabView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TabView[] = {
        { "container_from_index", reinterpret_cast<PyCFunction>(TabView_ContainerFromIndex), METH_VARARGS, nullptr },
        { "container_from_item", reinterpret_cast<PyCFunction>(TabView_ContainerFromItem), METH_VARARGS, nullptr },
        { "add_add_tab_button_click", reinterpret_cast<PyCFunction>(TabView_add_AddTabButtonClick), METH_O, nullptr },
        { "remove_add_tab_button_click", reinterpret_cast<PyCFunction>(TabView_remove_AddTabButtonClick), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(TabView_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(TabView_remove_SelectionChanged), METH_O, nullptr },
        { "add_tab_close_requested", reinterpret_cast<PyCFunction>(TabView_add_TabCloseRequested), METH_O, nullptr },
        { "remove_tab_close_requested", reinterpret_cast<PyCFunction>(TabView_remove_TabCloseRequested), METH_O, nullptr },
        { "add_tab_drag_completed", reinterpret_cast<PyCFunction>(TabView_add_TabDragCompleted), METH_O, nullptr },
        { "remove_tab_drag_completed", reinterpret_cast<PyCFunction>(TabView_remove_TabDragCompleted), METH_O, nullptr },
        { "add_tab_drag_starting", reinterpret_cast<PyCFunction>(TabView_add_TabDragStarting), METH_O, nullptr },
        { "remove_tab_drag_starting", reinterpret_cast<PyCFunction>(TabView_remove_TabDragStarting), METH_O, nullptr },
        { "add_tab_dropped_outside", reinterpret_cast<PyCFunction>(TabView_add_TabDroppedOutside), METH_O, nullptr },
        { "remove_tab_dropped_outside", reinterpret_cast<PyCFunction>(TabView_remove_TabDroppedOutside), METH_O, nullptr },
        { "add_tab_items_changed", reinterpret_cast<PyCFunction>(TabView_add_TabItemsChanged), METH_O, nullptr },
        { "remove_tab_items_changed", reinterpret_cast<PyCFunction>(TabView_remove_TabItemsChanged), METH_O, nullptr },
        { "add_tab_strip_drag_over", reinterpret_cast<PyCFunction>(TabView_add_TabStripDragOver), METH_O, nullptr },
        { "remove_tab_strip_drag_over", reinterpret_cast<PyCFunction>(TabView_remove_TabStripDragOver), METH_O, nullptr },
        { "add_tab_strip_drop", reinterpret_cast<PyCFunction>(TabView_add_TabStripDrop), METH_O, nullptr },
        { "remove_tab_strip_drop", reinterpret_cast<PyCFunction>(TabView_remove_TabStripDrop), METH_O, nullptr },
        { "_assign_array_", _assign_array_TabView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TabView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TabView[] = {
        { "tab_width_mode", reinterpret_cast<getter>(TabView_get_TabWidthMode), reinterpret_cast<setter>(TabView_put_TabWidthMode), nullptr, nullptr },
        { "tab_strip_header_template", reinterpret_cast<getter>(TabView_get_TabStripHeaderTemplate), reinterpret_cast<setter>(TabView_put_TabStripHeaderTemplate), nullptr, nullptr },
        { "tab_strip_header", reinterpret_cast<getter>(TabView_get_TabStripHeader), reinterpret_cast<setter>(TabView_put_TabStripHeader), nullptr, nullptr },
        { "tab_strip_footer_template", reinterpret_cast<getter>(TabView_get_TabStripFooterTemplate), reinterpret_cast<setter>(TabView_put_TabStripFooterTemplate), nullptr, nullptr },
        { "tab_strip_footer", reinterpret_cast<getter>(TabView_get_TabStripFooter), reinterpret_cast<setter>(TabView_put_TabStripFooter), nullptr, nullptr },
        { "tab_items_source", reinterpret_cast<getter>(TabView_get_TabItemsSource), reinterpret_cast<setter>(TabView_put_TabItemsSource), nullptr, nullptr },
        { "tab_item_template_selector", reinterpret_cast<getter>(TabView_get_TabItemTemplateSelector), reinterpret_cast<setter>(TabView_put_TabItemTemplateSelector), nullptr, nullptr },
        { "tab_item_template", reinterpret_cast<getter>(TabView_get_TabItemTemplate), reinterpret_cast<setter>(TabView_put_TabItemTemplate), nullptr, nullptr },
        { "selected_item", reinterpret_cast<getter>(TabView_get_SelectedItem), reinterpret_cast<setter>(TabView_put_SelectedItem), nullptr, nullptr },
        { "selected_index", reinterpret_cast<getter>(TabView_get_SelectedIndex), reinterpret_cast<setter>(TabView_put_SelectedIndex), nullptr, nullptr },
        { "is_add_tab_button_visible", reinterpret_cast<getter>(TabView_get_IsAddTabButtonVisible), reinterpret_cast<setter>(TabView_put_IsAddTabButtonVisible), nullptr, nullptr },
        { "close_button_overlay_mode", reinterpret_cast<getter>(TabView_get_CloseButtonOverlayMode), reinterpret_cast<setter>(TabView_put_CloseButtonOverlayMode), nullptr, nullptr },
        { "can_reorder_tabs", reinterpret_cast<getter>(TabView_get_CanReorderTabs), reinterpret_cast<setter>(TabView_put_CanReorderTabs), nullptr, nullptr },
        { "can_drag_tabs", reinterpret_cast<getter>(TabView_get_CanDragTabs), reinterpret_cast<setter>(TabView_put_CanDragTabs), nullptr, nullptr },
        { "allow_drop_tabs", reinterpret_cast<getter>(TabView_get_AllowDropTabs), reinterpret_cast<setter>(TabView_put_AllowDropTabs), nullptr, nullptr },
        { "add_tab_button_command_parameter", reinterpret_cast<getter>(TabView_get_AddTabButtonCommandParameter), reinterpret_cast<setter>(TabView_put_AddTabButtonCommandParameter), nullptr, nullptr },
        { "add_tab_button_command", reinterpret_cast<getter>(TabView_get_AddTabButtonCommand), reinterpret_cast<setter>(TabView_put_AddTabButtonCommand), nullptr, nullptr },
        { "tab_items", reinterpret_cast<getter>(TabView_get_TabItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TabView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TabView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TabView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TabView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TabView) },
        { },
    };

    static PyType_Spec type_spec_TabView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TabView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TabView
    };

    static PyGetSetDef getset_TabView_Static[] = {
        { "add_tab_button_command_parameter_property", reinterpret_cast<getter>(TabView_get_AddTabButtonCommandParameterProperty), nullptr, nullptr, nullptr },
        { "add_tab_button_command_property", reinterpret_cast<getter>(TabView_get_AddTabButtonCommandProperty), nullptr, nullptr, nullptr },
        { "allow_drop_tabs_property", reinterpret_cast<getter>(TabView_get_AllowDropTabsProperty), nullptr, nullptr, nullptr },
        { "can_drag_tabs_property", reinterpret_cast<getter>(TabView_get_CanDragTabsProperty), nullptr, nullptr, nullptr },
        { "can_reorder_tabs_property", reinterpret_cast<getter>(TabView_get_CanReorderTabsProperty), nullptr, nullptr, nullptr },
        { "close_button_overlay_mode_property", reinterpret_cast<getter>(TabView_get_CloseButtonOverlayModeProperty), nullptr, nullptr, nullptr },
        { "is_add_tab_button_visible_property", reinterpret_cast<getter>(TabView_get_IsAddTabButtonVisibleProperty), nullptr, nullptr, nullptr },
        { "selected_index_property", reinterpret_cast<getter>(TabView_get_SelectedIndexProperty), nullptr, nullptr, nullptr },
        { "selected_item_property", reinterpret_cast<getter>(TabView_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { "tab_item_template_property", reinterpret_cast<getter>(TabView_get_TabItemTemplateProperty), nullptr, nullptr, nullptr },
        { "tab_item_template_selector_property", reinterpret_cast<getter>(TabView_get_TabItemTemplateSelectorProperty), nullptr, nullptr, nullptr },
        { "tab_items_property", reinterpret_cast<getter>(TabView_get_TabItemsProperty), nullptr, nullptr, nullptr },
        { "tab_items_source_property", reinterpret_cast<getter>(TabView_get_TabItemsSourceProperty), nullptr, nullptr, nullptr },
        { "tab_strip_footer_property", reinterpret_cast<getter>(TabView_get_TabStripFooterProperty), nullptr, nullptr, nullptr },
        { "tab_strip_footer_template_property", reinterpret_cast<getter>(TabView_get_TabStripFooterTemplateProperty), nullptr, nullptr, nullptr },
        { "tab_strip_header_property", reinterpret_cast<getter>(TabView_get_TabStripHeaderProperty), nullptr, nullptr, nullptr },
        { "tab_strip_header_template_property", reinterpret_cast<getter>(TabView_get_TabStripHeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "tab_width_mode_property", reinterpret_cast<getter>(TabView_get_TabWidthModeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TabView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TabView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TabView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TabView_Static) },
        { }
    };

    static PyType_Spec type_spec_TabView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TabView_Static
    };

    // ----- TabViewItem class --------------------

    static PyObject* _new_TabViewItem(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::Microsoft::UI::Xaml::Controls::TabViewItem 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_TabViewItem(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TabViewItem_get_IsClosable(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"IsClosable"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsClosable());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabViewItem_put_IsClosable(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"IsClosable"))
        {
            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.IsClosable(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabViewItem_get_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"IconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabViewItem_put_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"IconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

            self->obj.IconSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabViewItem_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabViewItem_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabViewItem_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabViewItem_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabViewItem_get_TabViewTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"TabViewTemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabViewTemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItem_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabViewItem::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItem_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabViewItem::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItem_get_IconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"IconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabViewItem::IconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItem_get_IsClosableProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"IsClosableProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabViewItem::IsClosableProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItem_get_TabViewTemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"TabViewTemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabViewItem::TabViewTemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItem_add_CloseRequested(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"CloseRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TabViewItem, winrt::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs>>(arg);

            return py::convert(self->obj.CloseRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItem_remove_CloseRequested(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TabViewItem", L"CloseRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CloseRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TabViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TabViewItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TabViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TabViewItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TabViewItem[] = {
        { "add_close_requested", reinterpret_cast<PyCFunction>(TabViewItem_add_CloseRequested), METH_O, nullptr },
        { "remove_close_requested", reinterpret_cast<PyCFunction>(TabViewItem_remove_CloseRequested), METH_O, nullptr },
        { "_assign_array_", _assign_array_TabViewItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TabViewItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TabViewItem[] = {
        { "is_closable", reinterpret_cast<getter>(TabViewItem_get_IsClosable), reinterpret_cast<setter>(TabViewItem_put_IsClosable), nullptr, nullptr },
        { "icon_source", reinterpret_cast<getter>(TabViewItem_get_IconSource), reinterpret_cast<setter>(TabViewItem_put_IconSource), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(TabViewItem_get_HeaderTemplate), reinterpret_cast<setter>(TabViewItem_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(TabViewItem_get_Header), reinterpret_cast<setter>(TabViewItem_put_Header), nullptr, nullptr },
        { "tab_view_template_settings", reinterpret_cast<getter>(TabViewItem_get_TabViewTemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TabViewItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TabViewItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TabViewItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TabViewItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TabViewItem) },
        { },
    };

    static PyType_Spec type_spec_TabViewItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TabViewItem
    };

    static PyGetSetDef getset_TabViewItem_Static[] = {
        { "header_property", reinterpret_cast<getter>(TabViewItem_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(TabViewItem_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "icon_source_property", reinterpret_cast<getter>(TabViewItem_get_IconSourceProperty), nullptr, nullptr, nullptr },
        { "is_closable_property", reinterpret_cast<getter>(TabViewItem_get_IsClosableProperty), nullptr, nullptr, nullptr },
        { "tab_view_template_settings_property", reinterpret_cast<getter>(TabViewItem_get_TabViewTemplateSettingsProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TabViewItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TabViewItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TabViewItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TabViewItem_Static) },
        { }
    };

    static PyType_Spec type_spec_TabViewItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TabViewItem_Static
    };

    // ----- TabViewItemTemplateSettings class --------------------

    static PyObject* _new_TabViewItemTemplateSettings(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::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings 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_TabViewItemTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TabViewItemTemplateSettings_get_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings", L"IconElement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconElement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabViewItemTemplateSettings_put_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings", L"IconElement"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.IconElement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabViewItemTemplateSettings_get_TabGeometry(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings", L"TabGeometry"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TabGeometry());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabViewItemTemplateSettings_put_TabGeometry(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings", L"TabGeometry"))
        {
            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::Microsoft::UI::Xaml::Media::Geometry>(arg);

            self->obj.TabGeometry(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabViewItemTemplateSettings_get_IconElementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings", L"IconElementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings::IconElementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewItemTemplateSettings_get_TabGeometryProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings", L"TabGeometryProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings::TabGeometryProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TabViewItemTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TabViewItemTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TabViewItemTemplateSettings[] = {
        { "_assign_array_", _assign_array_TabViewItemTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TabViewItemTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TabViewItemTemplateSettings[] = {
        { "icon_element", reinterpret_cast<getter>(TabViewItemTemplateSettings_get_IconElement), reinterpret_cast<setter>(TabViewItemTemplateSettings_put_IconElement), nullptr, nullptr },
        { "tab_geometry", reinterpret_cast<getter>(TabViewItemTemplateSettings_get_TabGeometry), reinterpret_cast<setter>(TabViewItemTemplateSettings_put_TabGeometry), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TabViewItemTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TabViewItemTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TabViewItemTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TabViewItemTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TabViewItemTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_TabViewItemTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewItemTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewItemTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TabViewItemTemplateSettings
    };

    static PyGetSetDef getset_TabViewItemTemplateSettings_Static[] = {
        { "icon_element_property", reinterpret_cast<getter>(TabViewItemTemplateSettings_get_IconElementProperty), nullptr, nullptr, nullptr },
        { "tab_geometry_property", reinterpret_cast<getter>(TabViewItemTemplateSettings_get_TabGeometryProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TabViewItemTemplateSettings_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TabViewItemTemplateSettings_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TabViewItemTemplateSettings_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TabViewItemTemplateSettings_Static) },
        { }
    };

    static PyType_Spec type_spec_TabViewItemTemplateSettings_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewItemTemplateSettings_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TabViewItemTemplateSettings_Static
    };

    // ----- TabViewTabCloseRequestedEventArgs class --------------------

    static PyObject* _new_TabViewTabCloseRequestedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TabViewTabCloseRequestedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TabViewTabCloseRequestedEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabCloseRequestedEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewTabCloseRequestedEventArgs_get_Tab(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabCloseRequestedEventArgs", L"Tab"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Tab());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TabViewTabCloseRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TabViewTabCloseRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TabViewTabCloseRequestedEventArgs[] = {
        { "_assign_array_", _assign_array_TabViewTabCloseRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TabViewTabCloseRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TabViewTabCloseRequestedEventArgs[] = {
        { "item", reinterpret_cast<getter>(TabViewTabCloseRequestedEventArgs_get_Item), nullptr, nullptr, nullptr },
        { "tab", reinterpret_cast<getter>(TabViewTabCloseRequestedEventArgs_get_Tab), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TabViewTabCloseRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TabViewTabCloseRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TabViewTabCloseRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TabViewTabCloseRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TabViewTabCloseRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TabViewTabCloseRequestedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewTabCloseRequestedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabCloseRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TabViewTabCloseRequestedEventArgs
    };

    // ----- TabViewTabDragCompletedEventArgs class --------------------

    static PyObject* _new_TabViewTabDragCompletedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TabViewTabDragCompletedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TabViewTabDragCompletedEventArgs_get_DropResult(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragCompletedEventArgs", L"DropResult"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DropResult());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewTabDragCompletedEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragCompletedEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewTabDragCompletedEventArgs_get_Tab(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragCompletedEventArgs", L"Tab"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Tab());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TabViewTabDragCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TabViewTabDragCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TabViewTabDragCompletedEventArgs[] = {
        { "_assign_array_", _assign_array_TabViewTabDragCompletedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TabViewTabDragCompletedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TabViewTabDragCompletedEventArgs[] = {
        { "drop_result", reinterpret_cast<getter>(TabViewTabDragCompletedEventArgs_get_DropResult), nullptr, nullptr, nullptr },
        { "item", reinterpret_cast<getter>(TabViewTabDragCompletedEventArgs_get_Item), nullptr, nullptr, nullptr },
        { "tab", reinterpret_cast<getter>(TabViewTabDragCompletedEventArgs_get_Tab), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TabViewTabDragCompletedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TabViewTabDragCompletedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TabViewTabDragCompletedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TabViewTabDragCompletedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TabViewTabDragCompletedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TabViewTabDragCompletedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewTabDragCompletedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragCompletedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TabViewTabDragCompletedEventArgs
    };

    // ----- TabViewTabDragStartingEventArgs class --------------------

    static PyObject* _new_TabViewTabDragStartingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TabViewTabDragStartingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TabViewTabDragStartingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TabViewTabDragStartingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TabViewTabDragStartingEventArgs_get_Data(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs", 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 PyObject* TabViewTabDragStartingEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewTabDragStartingEventArgs_get_Tab(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs", L"Tab"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Tab());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TabViewTabDragStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TabViewTabDragStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TabViewTabDragStartingEventArgs[] = {
        { "_assign_array_", _assign_array_TabViewTabDragStartingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TabViewTabDragStartingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TabViewTabDragStartingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(TabViewTabDragStartingEventArgs_get_Cancel), reinterpret_cast<setter>(TabViewTabDragStartingEventArgs_put_Cancel), nullptr, nullptr },
        { "data", reinterpret_cast<getter>(TabViewTabDragStartingEventArgs_get_Data), nullptr, nullptr, nullptr },
        { "item", reinterpret_cast<getter>(TabViewTabDragStartingEventArgs_get_Item), nullptr, nullptr, nullptr },
        { "tab", reinterpret_cast<getter>(TabViewTabDragStartingEventArgs_get_Tab), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TabViewTabDragStartingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TabViewTabDragStartingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TabViewTabDragStartingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TabViewTabDragStartingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TabViewTabDragStartingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TabViewTabDragStartingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewTabDragStartingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TabViewTabDragStartingEventArgs
    };

    // ----- TabViewTabDroppedOutsideEventArgs class --------------------

    static PyObject* _new_TabViewTabDroppedOutsideEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TabViewTabDroppedOutsideEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TabViewTabDroppedOutsideEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDroppedOutsideEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TabViewTabDroppedOutsideEventArgs_get_Tab(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TabViewTabDroppedOutsideEventArgs", L"Tab"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Tab());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TabViewTabDroppedOutsideEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TabViewTabDroppedOutsideEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TabViewTabDroppedOutsideEventArgs[] = {
        { "_assign_array_", _assign_array_TabViewTabDroppedOutsideEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TabViewTabDroppedOutsideEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TabViewTabDroppedOutsideEventArgs[] = {
        { "item", reinterpret_cast<getter>(TabViewTabDroppedOutsideEventArgs_get_Item), nullptr, nullptr, nullptr },
        { "tab", reinterpret_cast<getter>(TabViewTabDroppedOutsideEventArgs_get_Tab), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TabViewTabDroppedOutsideEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TabViewTabDroppedOutsideEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TabViewTabDroppedOutsideEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TabViewTabDroppedOutsideEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TabViewTabDroppedOutsideEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TabViewTabDroppedOutsideEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TabViewTabDroppedOutsideEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TabViewTabDroppedOutsideEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TabViewTabDroppedOutsideEventArgs
    };

    // ----- TeachingTip class --------------------

    static PyObject* _new_TeachingTip(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::Microsoft::UI::Xaml::Controls::TeachingTip 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_TeachingTip(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TeachingTip_get_Title(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Title"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Title());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_Title(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Title"))
        {
            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.Title(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_Target(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", 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 int TeachingTip_put_Target(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Target"))
        {
            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::Microsoft::UI::Xaml::FrameworkElement>(arg);

            self->obj.Target(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_TailVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"TailVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TailVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_TailVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"TailVisibility"))
        {
            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::Microsoft::UI::Xaml::Controls::TeachingTipTailVisibility>(arg);

            self->obj.TailVisibility(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_Subtitle(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Subtitle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Subtitle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_Subtitle(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Subtitle"))
        {
            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.Subtitle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_ShouldConstrainToRootBounds(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ShouldConstrainToRootBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ShouldConstrainToRootBounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_ShouldConstrainToRootBounds(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ShouldConstrainToRootBounds"))
        {
            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.ShouldConstrainToRootBounds(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_PreferredPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"PreferredPlacement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreferredPlacement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_PreferredPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"PreferredPlacement"))
        {
            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::Microsoft::UI::Xaml::Controls::TeachingTipPlacementMode>(arg);

            self->obj.PreferredPlacement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_PlacementMargin(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"PlacementMargin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlacementMargin());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_PlacementMargin(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"PlacementMargin"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.PlacementMargin(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IsOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsOpen());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IsOpen"))
        {
            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.IsOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_IsLightDismissEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IsLightDismissEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsLightDismissEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_IsLightDismissEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IsLightDismissEnabled"))
        {
            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.IsLightDismissEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IconSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_IconSource(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IconSource"))
        {
            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::Microsoft::UI::Xaml::Controls::IconSource>(arg);

            self->obj.IconSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_HeroContentPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"HeroContentPlacement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeroContentPlacement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_HeroContentPlacement(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"HeroContentPlacement"))
        {
            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::Microsoft::UI::Xaml::Controls::TeachingTipHeroContentPlacementMode>(arg);

            self->obj.HeroContentPlacement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_HeroContent(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"HeroContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeroContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_HeroContent(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"HeroContent"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.HeroContent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_CloseButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.CloseButtonStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonContent(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_CloseButtonContent(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonContent"))
        {
            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.CloseButtonContent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonCommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonCommandParameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_CloseButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonCommandParameter"))
        {
            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.CloseButtonCommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonCommand"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CloseButtonCommand());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_CloseButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonCommand"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

            self->obj.CloseButtonCommand(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActionButtonStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_ActionButtonStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.ActionButtonStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonContent(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActionButtonContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_ActionButtonContent(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonContent"))
        {
            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.ActionButtonContent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonCommandParameter"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActionButtonCommandParameter());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_ActionButtonCommandParameter(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonCommandParameter"))
        {
            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.ActionButtonCommandParameter(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonCommand"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ActionButtonCommand());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTip_put_ActionButtonCommand(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonCommand"))
        {
            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::Microsoft::UI::Xaml::Input::ICommand>(arg);

            self->obj.ActionButtonCommand(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTip_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonCommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonCommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::ActionButtonCommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonCommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonCommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::ActionButtonCommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::ActionButtonContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_ActionButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::ActionButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonCommandParameterProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonCommandParameterProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::CloseButtonCommandParameterProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonCommandProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonCommandProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::CloseButtonCommandProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::CloseButtonContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_CloseButtonStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::CloseButtonStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_HeroContentPlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"HeroContentPlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::HeroContentPlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_HeroContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"HeroContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::HeroContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_IconSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IconSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::IconSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_IsLightDismissEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IsLightDismissEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::IsLightDismissEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_IsOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"IsOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::IsOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_PlacementMarginProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"PlacementMarginProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::PlacementMarginProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_PreferredPlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"PreferredPlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::PreferredPlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_ShouldConstrainToRootBoundsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ShouldConstrainToRootBoundsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::ShouldConstrainToRootBoundsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_SubtitleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"SubtitleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::SubtitleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_TailVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"TailVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::TailVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_TargetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"TargetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::TargetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_TemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"TemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::TemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_get_TitleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"TitleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTip::TitleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_add_ActionButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TeachingTip, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ActionButtonClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_remove_ActionButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"ActionButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ActionButtonClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_add_CloseButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TeachingTip, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.CloseButtonClick(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_remove_CloseButtonClick(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"CloseButtonClick"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CloseButtonClick(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_add_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TeachingTip, winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs>>(arg);

            return py::convert(self->obj.Closed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_remove_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Closed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_add_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TeachingTip, winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs>>(arg);

            return py::convert(self->obj.Closing(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTip_remove_Closing(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TeachingTip", L"Closing"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Closing(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TeachingTip(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TeachingTip>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TeachingTip(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TeachingTip>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TeachingTip[] = {
        { "add_action_button_click", reinterpret_cast<PyCFunction>(TeachingTip_add_ActionButtonClick), METH_O, nullptr },
        { "remove_action_button_click", reinterpret_cast<PyCFunction>(TeachingTip_remove_ActionButtonClick), METH_O, nullptr },
        { "add_close_button_click", reinterpret_cast<PyCFunction>(TeachingTip_add_CloseButtonClick), METH_O, nullptr },
        { "remove_close_button_click", reinterpret_cast<PyCFunction>(TeachingTip_remove_CloseButtonClick), METH_O, nullptr },
        { "add_closed", reinterpret_cast<PyCFunction>(TeachingTip_add_Closed), METH_O, nullptr },
        { "remove_closed", reinterpret_cast<PyCFunction>(TeachingTip_remove_Closed), METH_O, nullptr },
        { "add_closing", reinterpret_cast<PyCFunction>(TeachingTip_add_Closing), METH_O, nullptr },
        { "remove_closing", reinterpret_cast<PyCFunction>(TeachingTip_remove_Closing), METH_O, nullptr },
        { "_assign_array_", _assign_array_TeachingTip, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TeachingTip), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TeachingTip[] = {
        { "title", reinterpret_cast<getter>(TeachingTip_get_Title), reinterpret_cast<setter>(TeachingTip_put_Title), nullptr, nullptr },
        { "target", reinterpret_cast<getter>(TeachingTip_get_Target), reinterpret_cast<setter>(TeachingTip_put_Target), nullptr, nullptr },
        { "tail_visibility", reinterpret_cast<getter>(TeachingTip_get_TailVisibility), reinterpret_cast<setter>(TeachingTip_put_TailVisibility), nullptr, nullptr },
        { "subtitle", reinterpret_cast<getter>(TeachingTip_get_Subtitle), reinterpret_cast<setter>(TeachingTip_put_Subtitle), nullptr, nullptr },
        { "should_constrain_to_root_bounds", reinterpret_cast<getter>(TeachingTip_get_ShouldConstrainToRootBounds), reinterpret_cast<setter>(TeachingTip_put_ShouldConstrainToRootBounds), nullptr, nullptr },
        { "preferred_placement", reinterpret_cast<getter>(TeachingTip_get_PreferredPlacement), reinterpret_cast<setter>(TeachingTip_put_PreferredPlacement), nullptr, nullptr },
        { "placement_margin", reinterpret_cast<getter>(TeachingTip_get_PlacementMargin), reinterpret_cast<setter>(TeachingTip_put_PlacementMargin), nullptr, nullptr },
        { "is_open", reinterpret_cast<getter>(TeachingTip_get_IsOpen), reinterpret_cast<setter>(TeachingTip_put_IsOpen), nullptr, nullptr },
        { "is_light_dismiss_enabled", reinterpret_cast<getter>(TeachingTip_get_IsLightDismissEnabled), reinterpret_cast<setter>(TeachingTip_put_IsLightDismissEnabled), nullptr, nullptr },
        { "icon_source", reinterpret_cast<getter>(TeachingTip_get_IconSource), reinterpret_cast<setter>(TeachingTip_put_IconSource), nullptr, nullptr },
        { "hero_content_placement", reinterpret_cast<getter>(TeachingTip_get_HeroContentPlacement), reinterpret_cast<setter>(TeachingTip_put_HeroContentPlacement), nullptr, nullptr },
        { "hero_content", reinterpret_cast<getter>(TeachingTip_get_HeroContent), reinterpret_cast<setter>(TeachingTip_put_HeroContent), nullptr, nullptr },
        { "close_button_style", reinterpret_cast<getter>(TeachingTip_get_CloseButtonStyle), reinterpret_cast<setter>(TeachingTip_put_CloseButtonStyle), nullptr, nullptr },
        { "close_button_content", reinterpret_cast<getter>(TeachingTip_get_CloseButtonContent), reinterpret_cast<setter>(TeachingTip_put_CloseButtonContent), nullptr, nullptr },
        { "close_button_command_parameter", reinterpret_cast<getter>(TeachingTip_get_CloseButtonCommandParameter), reinterpret_cast<setter>(TeachingTip_put_CloseButtonCommandParameter), nullptr, nullptr },
        { "close_button_command", reinterpret_cast<getter>(TeachingTip_get_CloseButtonCommand), reinterpret_cast<setter>(TeachingTip_put_CloseButtonCommand), nullptr, nullptr },
        { "action_button_style", reinterpret_cast<getter>(TeachingTip_get_ActionButtonStyle), reinterpret_cast<setter>(TeachingTip_put_ActionButtonStyle), nullptr, nullptr },
        { "action_button_content", reinterpret_cast<getter>(TeachingTip_get_ActionButtonContent), reinterpret_cast<setter>(TeachingTip_put_ActionButtonContent), nullptr, nullptr },
        { "action_button_command_parameter", reinterpret_cast<getter>(TeachingTip_get_ActionButtonCommandParameter), reinterpret_cast<setter>(TeachingTip_put_ActionButtonCommandParameter), nullptr, nullptr },
        { "action_button_command", reinterpret_cast<getter>(TeachingTip_get_ActionButtonCommand), reinterpret_cast<setter>(TeachingTip_put_ActionButtonCommand), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(TeachingTip_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TeachingTip[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TeachingTip) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TeachingTip) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TeachingTip) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TeachingTip) },
        { },
    };

    static PyType_Spec type_spec_TeachingTip =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TeachingTip",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTip),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TeachingTip
    };

    static PyGetSetDef getset_TeachingTip_Static[] = {
        { "action_button_command_parameter_property", reinterpret_cast<getter>(TeachingTip_get_ActionButtonCommandParameterProperty), nullptr, nullptr, nullptr },
        { "action_button_command_property", reinterpret_cast<getter>(TeachingTip_get_ActionButtonCommandProperty), nullptr, nullptr, nullptr },
        { "action_button_content_property", reinterpret_cast<getter>(TeachingTip_get_ActionButtonContentProperty), nullptr, nullptr, nullptr },
        { "action_button_style_property", reinterpret_cast<getter>(TeachingTip_get_ActionButtonStyleProperty), nullptr, nullptr, nullptr },
        { "close_button_command_parameter_property", reinterpret_cast<getter>(TeachingTip_get_CloseButtonCommandParameterProperty), nullptr, nullptr, nullptr },
        { "close_button_command_property", reinterpret_cast<getter>(TeachingTip_get_CloseButtonCommandProperty), nullptr, nullptr, nullptr },
        { "close_button_content_property", reinterpret_cast<getter>(TeachingTip_get_CloseButtonContentProperty), nullptr, nullptr, nullptr },
        { "close_button_style_property", reinterpret_cast<getter>(TeachingTip_get_CloseButtonStyleProperty), nullptr, nullptr, nullptr },
        { "hero_content_placement_property", reinterpret_cast<getter>(TeachingTip_get_HeroContentPlacementProperty), nullptr, nullptr, nullptr },
        { "hero_content_property", reinterpret_cast<getter>(TeachingTip_get_HeroContentProperty), nullptr, nullptr, nullptr },
        { "icon_source_property", reinterpret_cast<getter>(TeachingTip_get_IconSourceProperty), nullptr, nullptr, nullptr },
        { "is_light_dismiss_enabled_property", reinterpret_cast<getter>(TeachingTip_get_IsLightDismissEnabledProperty), nullptr, nullptr, nullptr },
        { "is_open_property", reinterpret_cast<getter>(TeachingTip_get_IsOpenProperty), nullptr, nullptr, nullptr },
        { "placement_margin_property", reinterpret_cast<getter>(TeachingTip_get_PlacementMarginProperty), nullptr, nullptr, nullptr },
        { "preferred_placement_property", reinterpret_cast<getter>(TeachingTip_get_PreferredPlacementProperty), nullptr, nullptr, nullptr },
        { "should_constrain_to_root_bounds_property", reinterpret_cast<getter>(TeachingTip_get_ShouldConstrainToRootBoundsProperty), nullptr, nullptr, nullptr },
        { "subtitle_property", reinterpret_cast<getter>(TeachingTip_get_SubtitleProperty), nullptr, nullptr, nullptr },
        { "tail_visibility_property", reinterpret_cast<getter>(TeachingTip_get_TailVisibilityProperty), nullptr, nullptr, nullptr },
        { "target_property", reinterpret_cast<getter>(TeachingTip_get_TargetProperty), nullptr, nullptr, nullptr },
        { "template_settings_property", reinterpret_cast<getter>(TeachingTip_get_TemplateSettingsProperty), nullptr, nullptr, nullptr },
        { "title_property", reinterpret_cast<getter>(TeachingTip_get_TitleProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TeachingTip_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TeachingTip_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TeachingTip_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TeachingTip_Static) },
        { }
    };

    static PyType_Spec type_spec_TeachingTip_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TeachingTip_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TeachingTip_Static
    };

    // ----- TeachingTipClosedEventArgs class --------------------

    static PyObject* _new_TeachingTipClosedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TeachingTipClosedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TeachingTipClosedEventArgs_get_Reason(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipClosedEventArgs", L"Reason"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Reason());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TeachingTipClosedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TeachingTipClosedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TeachingTipClosedEventArgs[] = {
        { "_assign_array_", _assign_array_TeachingTipClosedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TeachingTipClosedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TeachingTipClosedEventArgs[] = {
        { "reason", reinterpret_cast<getter>(TeachingTipClosedEventArgs_get_Reason), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TeachingTipClosedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TeachingTipClosedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TeachingTipClosedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TeachingTipClosedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TeachingTipClosedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TeachingTipClosedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TeachingTipClosedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TeachingTipClosedEventArgs
    };

    // ----- TeachingTipClosingEventArgs class --------------------

    static PyObject* _new_TeachingTipClosingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TeachingTipClosingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TeachingTipClosingEventArgs_GetDeferral(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipClosingEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetDeferral());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TeachingTipClosingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipClosingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTipClosingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipClosingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTipClosingEventArgs_get_Reason(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipClosingEventArgs", L"Reason"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Reason());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TeachingTipClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TeachingTipClosingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TeachingTipClosingEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(TeachingTipClosingEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_TeachingTipClosingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TeachingTipClosingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TeachingTipClosingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(TeachingTipClosingEventArgs_get_Cancel), reinterpret_cast<setter>(TeachingTipClosingEventArgs_put_Cancel), nullptr, nullptr },
        { "reason", reinterpret_cast<getter>(TeachingTipClosingEventArgs_get_Reason), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TeachingTipClosingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TeachingTipClosingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TeachingTipClosingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TeachingTipClosingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TeachingTipClosingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TeachingTipClosingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TeachingTipClosingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipClosingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TeachingTipClosingEventArgs
    };

    // ----- TeachingTipTemplateSettings class --------------------

    static PyObject* _new_TeachingTipTemplateSettings(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::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings 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_TeachingTipTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TeachingTipTemplateSettings_get_TopRightHighlightMargin(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"TopRightHighlightMargin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopRightHighlightMargin());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTipTemplateSettings_put_TopRightHighlightMargin(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"TopRightHighlightMargin"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.TopRightHighlightMargin(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTipTemplateSettings_get_TopLeftHighlightMargin(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"TopLeftHighlightMargin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TopLeftHighlightMargin());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTipTemplateSettings_put_TopLeftHighlightMargin(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"TopLeftHighlightMargin"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.TopLeftHighlightMargin(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTipTemplateSettings_get_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"IconElement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IconElement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TeachingTipTemplateSettings_put_IconElement(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"IconElement"))
        {
            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::Microsoft::UI::Xaml::Controls::IconElement>(arg);

            self->obj.IconElement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TeachingTipTemplateSettings_get_IconElementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"IconElementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings::IconElementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTipTemplateSettings_get_TopLeftHighlightMarginProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"TopLeftHighlightMarginProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings::TopLeftHighlightMarginProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TeachingTipTemplateSettings_get_TopRightHighlightMarginProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings", L"TopRightHighlightMarginProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings::TopRightHighlightMarginProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TeachingTipTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TeachingTipTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TeachingTipTemplateSettings[] = {
        { "_assign_array_", _assign_array_TeachingTipTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TeachingTipTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TeachingTipTemplateSettings[] = {
        { "top_right_highlight_margin", reinterpret_cast<getter>(TeachingTipTemplateSettings_get_TopRightHighlightMargin), reinterpret_cast<setter>(TeachingTipTemplateSettings_put_TopRightHighlightMargin), nullptr, nullptr },
        { "top_left_highlight_margin", reinterpret_cast<getter>(TeachingTipTemplateSettings_get_TopLeftHighlightMargin), reinterpret_cast<setter>(TeachingTipTemplateSettings_put_TopLeftHighlightMargin), nullptr, nullptr },
        { "icon_element", reinterpret_cast<getter>(TeachingTipTemplateSettings_get_IconElement), reinterpret_cast<setter>(TeachingTipTemplateSettings_put_IconElement), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TeachingTipTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TeachingTipTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TeachingTipTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TeachingTipTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TeachingTipTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_TeachingTipTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TeachingTipTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TeachingTipTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TeachingTipTemplateSettings
    };

    static PyGetSetDef getset_TeachingTipTemplateSettings_Static[] = {
        { "icon_element_property", reinterpret_cast<getter>(TeachingTipTemplateSettings_get_IconElementProperty), nullptr, nullptr, nullptr },
        { "top_left_highlight_margin_property", reinterpret_cast<getter>(TeachingTipTemplateSettings_get_TopLeftHighlightMarginProperty), nullptr, nullptr, nullptr },
        { "top_right_highlight_margin_property", reinterpret_cast<getter>(TeachingTipTemplateSettings_get_TopRightHighlightMarginProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TeachingTipTemplateSettings_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TeachingTipTemplateSettings_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TeachingTipTemplateSettings_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TeachingTipTemplateSettings_Static) },
        { }
    };

    static PyType_Spec type_spec_TeachingTipTemplateSettings_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TeachingTipTemplateSettings_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TeachingTipTemplateSettings_Static
    };

    // ----- TextBlock class --------------------

    static PyObject* _new_TextBlock(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::Microsoft::UI::Xaml::Controls::TextBlock 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_TextBlock(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextBlock_CopySelectionToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"CopySelectionToClipboard", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CopySelectionToClipboard();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBlock_GetAlphaMask(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"GetAlphaMask", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetAlphaMask());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBlock_Select(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Select", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Documents::TextPointer>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Documents::TextPointer>(args, 1);

                self->obj.Select(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBlock_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsColorFontEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsColorFontEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsColorFontEnabled"))
        {
            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.IsColorFontEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"LineHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LineHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_LineHeight(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"LineHeight"))
        {
            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<double>(arg);

            self->obj.LineHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"HorizontalTextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalTextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"HorizontalTextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.HorizontalTextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Foreground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Foreground());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_Foreground(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Foreground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.Foreground(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontWeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontWeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_FontWeight(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontWeight"))
        {
            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::UI::Text::FontWeight>(arg);

            self->obj.FontWeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_FontStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontStyle"))
        {
            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::UI::Text::FontStyle>(arg);

            self->obj.FontStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontStretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontStretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_FontStretch(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontStretch"))
        {
            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::UI::Text::FontStretch>(arg);

            self->obj.FontStretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_FontSize(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontSize"))
        {
            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<double>(arg);

            self->obj.FontSize(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontFamily"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.FontFamily());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_FontFamily(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontFamily"))
        {
            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::Microsoft::UI::Xaml::Media::FontFamily>(arg);

            self->obj.FontFamily(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_IsTextSelectionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextSelectionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextSelectionEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_IsTextSelectionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextSelectionEnabled"))
        {
            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.IsTextSelectionEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextScaleFactorEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextScaleFactorEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_IsTextScaleFactorEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextScaleFactorEnabled"))
        {
            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.IsTextScaleFactorEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"CharacterSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CharacterSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_CharacterSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"CharacterSpacing"))
        {
            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<int32_t>(arg);

            self->obj.CharacterSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextWrapping"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextWrapping());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextWrapping"))
        {
            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::Microsoft::UI::Xaml::TextWrapping>(arg);

            self->obj.TextWrapping(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_LineStackingStrategy(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"LineStackingStrategy"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LineStackingStrategy());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_LineStackingStrategy(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"LineStackingStrategy"))
        {
            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::Microsoft::UI::Xaml::LineStackingStrategy>(arg);

            self->obj.LineStackingStrategy(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_TextTrimming(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextTrimming"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextTrimming());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_TextTrimming(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextTrimming"))
        {
            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::Microsoft::UI::Xaml::TextTrimming>(arg);

            self->obj.TextTrimming(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextReadingOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextReadingOrder());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextReadingOrder"))
        {
            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::Microsoft::UI::Xaml::TextReadingOrder>(arg);

            self->obj.TextReadingOrder(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_TextLineBounds(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextLineBounds"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextLineBounds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_TextLineBounds(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextLineBounds"))
        {
            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::Microsoft::UI::Xaml::TextLineBounds>(arg);

            self->obj.TextLineBounds(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_TextDecorations(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextDecorations"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextDecorations());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_TextDecorations(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextDecorations"))
        {
            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::UI::Text::TextDecorations>(arg);

            self->obj.TextDecorations(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.TextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionHighlightColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionHighlightColor"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionFlyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

            self->obj.SelectionFlyout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Padding"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Padding());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_Padding(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Padding"))
        {
            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::Microsoft::UI::Xaml::Thickness>(arg);

            self->obj.Padding(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_OpticalMarginAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"OpticalMarginAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OpticalMarginAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_OpticalMarginAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"OpticalMarginAlignment"))
        {
            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::Microsoft::UI::Xaml::OpticalMarginAlignment>(arg);

            self->obj.OpticalMarginAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"MaxLines"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxLines());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBlock_put_MaxLines(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"MaxLines"))
        {
            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<int32_t>(arg);

            self->obj.MaxLines(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBlock_get_ContentEnd(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"ContentEnd"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentEnd());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_ContentStart(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"ContentStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ContentStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_Inlines(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"Inlines"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Inlines());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_IsTextTrimmed(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextTrimmed"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextTrimmed());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_SelectedText(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectedText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_SelectionEnd(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionEnd"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionEnd());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_SelectionStart(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextHighlighters(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextHighlighters"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextHighlighters());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_BaselineOffset(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"BaselineOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.BaselineOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_CharacterSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"CharacterSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::CharacterSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_FontFamilyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontFamilyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::FontFamilyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_FontSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::FontSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_FontStretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontStretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::FontStretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_FontStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::FontStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_FontWeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"FontWeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::FontWeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_ForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"ForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::ForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_HorizontalTextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"HorizontalTextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::HorizontalTextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_IsColorFontEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsColorFontEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::IsColorFontEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_IsTextScaleFactorEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextScaleFactorEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::IsTextScaleFactorEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_IsTextSelectionEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextSelectionEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::IsTextSelectionEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_IsTextTrimmedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextTrimmedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::IsTextTrimmedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_LineHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"LineHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::LineHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_LineStackingStrategyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"LineStackingStrategyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::LineStackingStrategyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_MaxLinesProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"MaxLinesProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::MaxLinesProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_OpticalMarginAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"OpticalMarginAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::OpticalMarginAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_PaddingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"PaddingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::PaddingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_SelectedTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectedTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::SelectedTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_SelectionFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::SelectionFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_SelectionHighlightColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionHighlightColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::SelectionHighlightColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::TextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextDecorationsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextDecorationsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::TextDecorationsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextLineBoundsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextLineBoundsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::TextLineBoundsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextReadingOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextReadingOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::TextReadingOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextTrimmingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextTrimmingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::TextTrimmingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_get_TextWrappingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"TextWrappingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBlock::TextWrappingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_add_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ContextMenuOpeningEventHandler>(arg);

            return py::convert(self->obj.ContextMenuOpening(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_remove_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ContextMenuOpening(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_add_IsTextTrimmedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextTrimmedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBlock, winrt::Microsoft::UI::Xaml::Controls::IsTextTrimmedChangedEventArgs>>(arg);

            return py::convert(self->obj.IsTextTrimmedChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_remove_IsTextTrimmedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"IsTextTrimmedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.IsTextTrimmedChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBlock_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBlock", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextBlock(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextBlock>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextBlock(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextBlock>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextBlock[] = {
        { "copy_selection_to_clipboard", reinterpret_cast<PyCFunction>(TextBlock_CopySelectionToClipboard), METH_VARARGS, nullptr },
        { "get_alpha_mask", reinterpret_cast<PyCFunction>(TextBlock_GetAlphaMask), METH_VARARGS, nullptr },
        { "select", reinterpret_cast<PyCFunction>(TextBlock_Select), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(TextBlock_SelectAll), METH_VARARGS, nullptr },
        { "add_context_menu_opening", reinterpret_cast<PyCFunction>(TextBlock_add_ContextMenuOpening), METH_O, nullptr },
        { "remove_context_menu_opening", reinterpret_cast<PyCFunction>(TextBlock_remove_ContextMenuOpening), METH_O, nullptr },
        { "add_is_text_trimmed_changed", reinterpret_cast<PyCFunction>(TextBlock_add_IsTextTrimmedChanged), METH_O, nullptr },
        { "remove_is_text_trimmed_changed", reinterpret_cast<PyCFunction>(TextBlock_remove_IsTextTrimmedChanged), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(TextBlock_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(TextBlock_remove_SelectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_TextBlock, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextBlock), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextBlock[] = {
        { "is_color_font_enabled", reinterpret_cast<getter>(TextBlock_get_IsColorFontEnabled), reinterpret_cast<setter>(TextBlock_put_IsColorFontEnabled), nullptr, nullptr },
        { "line_height", reinterpret_cast<getter>(TextBlock_get_LineHeight), reinterpret_cast<setter>(TextBlock_put_LineHeight), nullptr, nullptr },
        { "horizontal_text_alignment", reinterpret_cast<getter>(TextBlock_get_HorizontalTextAlignment), reinterpret_cast<setter>(TextBlock_put_HorizontalTextAlignment), nullptr, nullptr },
        { "foreground", reinterpret_cast<getter>(TextBlock_get_Foreground), reinterpret_cast<setter>(TextBlock_put_Foreground), nullptr, nullptr },
        { "font_weight", reinterpret_cast<getter>(TextBlock_get_FontWeight), reinterpret_cast<setter>(TextBlock_put_FontWeight), nullptr, nullptr },
        { "font_style", reinterpret_cast<getter>(TextBlock_get_FontStyle), reinterpret_cast<setter>(TextBlock_put_FontStyle), nullptr, nullptr },
        { "font_stretch", reinterpret_cast<getter>(TextBlock_get_FontStretch), reinterpret_cast<setter>(TextBlock_put_FontStretch), nullptr, nullptr },
        { "font_size", reinterpret_cast<getter>(TextBlock_get_FontSize), reinterpret_cast<setter>(TextBlock_put_FontSize), nullptr, nullptr },
        { "font_family", reinterpret_cast<getter>(TextBlock_get_FontFamily), reinterpret_cast<setter>(TextBlock_put_FontFamily), nullptr, nullptr },
        { "is_text_selection_enabled", reinterpret_cast<getter>(TextBlock_get_IsTextSelectionEnabled), reinterpret_cast<setter>(TextBlock_put_IsTextSelectionEnabled), nullptr, nullptr },
        { "is_text_scale_factor_enabled", reinterpret_cast<getter>(TextBlock_get_IsTextScaleFactorEnabled), reinterpret_cast<setter>(TextBlock_put_IsTextScaleFactorEnabled), nullptr, nullptr },
        { "character_spacing", reinterpret_cast<getter>(TextBlock_get_CharacterSpacing), reinterpret_cast<setter>(TextBlock_put_CharacterSpacing), nullptr, nullptr },
        { "text_wrapping", reinterpret_cast<getter>(TextBlock_get_TextWrapping), reinterpret_cast<setter>(TextBlock_put_TextWrapping), nullptr, nullptr },
        { "line_stacking_strategy", reinterpret_cast<getter>(TextBlock_get_LineStackingStrategy), reinterpret_cast<setter>(TextBlock_put_LineStackingStrategy), nullptr, nullptr },
        { "text_trimming", reinterpret_cast<getter>(TextBlock_get_TextTrimming), reinterpret_cast<setter>(TextBlock_put_TextTrimming), nullptr, nullptr },
        { "text_reading_order", reinterpret_cast<getter>(TextBlock_get_TextReadingOrder), reinterpret_cast<setter>(TextBlock_put_TextReadingOrder), nullptr, nullptr },
        { "text_line_bounds", reinterpret_cast<getter>(TextBlock_get_TextLineBounds), reinterpret_cast<setter>(TextBlock_put_TextLineBounds), nullptr, nullptr },
        { "text_decorations", reinterpret_cast<getter>(TextBlock_get_TextDecorations), reinterpret_cast<setter>(TextBlock_put_TextDecorations), nullptr, nullptr },
        { "text_alignment", reinterpret_cast<getter>(TextBlock_get_TextAlignment), reinterpret_cast<setter>(TextBlock_put_TextAlignment), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(TextBlock_get_Text), reinterpret_cast<setter>(TextBlock_put_Text), nullptr, nullptr },
        { "selection_highlight_color", reinterpret_cast<getter>(TextBlock_get_SelectionHighlightColor), reinterpret_cast<setter>(TextBlock_put_SelectionHighlightColor), nullptr, nullptr },
        { "selection_flyout", reinterpret_cast<getter>(TextBlock_get_SelectionFlyout), reinterpret_cast<setter>(TextBlock_put_SelectionFlyout), nullptr, nullptr },
        { "padding", reinterpret_cast<getter>(TextBlock_get_Padding), reinterpret_cast<setter>(TextBlock_put_Padding), nullptr, nullptr },
        { "optical_margin_alignment", reinterpret_cast<getter>(TextBlock_get_OpticalMarginAlignment), reinterpret_cast<setter>(TextBlock_put_OpticalMarginAlignment), nullptr, nullptr },
        { "max_lines", reinterpret_cast<getter>(TextBlock_get_MaxLines), reinterpret_cast<setter>(TextBlock_put_MaxLines), nullptr, nullptr },
        { "content_end", reinterpret_cast<getter>(TextBlock_get_ContentEnd), nullptr, nullptr, nullptr },
        { "content_start", reinterpret_cast<getter>(TextBlock_get_ContentStart), nullptr, nullptr, nullptr },
        { "inlines", reinterpret_cast<getter>(TextBlock_get_Inlines), nullptr, nullptr, nullptr },
        { "is_text_trimmed", reinterpret_cast<getter>(TextBlock_get_IsTextTrimmed), nullptr, nullptr, nullptr },
        { "selected_text", reinterpret_cast<getter>(TextBlock_get_SelectedText), nullptr, nullptr, nullptr },
        { "selection_end", reinterpret_cast<getter>(TextBlock_get_SelectionEnd), nullptr, nullptr, nullptr },
        { "selection_start", reinterpret_cast<getter>(TextBlock_get_SelectionStart), nullptr, nullptr, nullptr },
        { "text_highlighters", reinterpret_cast<getter>(TextBlock_get_TextHighlighters), nullptr, nullptr, nullptr },
        { "baseline_offset", reinterpret_cast<getter>(TextBlock_get_BaselineOffset), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextBlock[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextBlock) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextBlock) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextBlock) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextBlock) },
        { },
    };

    static PyType_Spec type_spec_TextBlock =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextBlock",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextBlock),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextBlock
    };

    static PyGetSetDef getset_TextBlock_Static[] = {
        { "character_spacing_property", reinterpret_cast<getter>(TextBlock_get_CharacterSpacingProperty), nullptr, nullptr, nullptr },
        { "font_family_property", reinterpret_cast<getter>(TextBlock_get_FontFamilyProperty), nullptr, nullptr, nullptr },
        { "font_size_property", reinterpret_cast<getter>(TextBlock_get_FontSizeProperty), nullptr, nullptr, nullptr },
        { "font_stretch_property", reinterpret_cast<getter>(TextBlock_get_FontStretchProperty), nullptr, nullptr, nullptr },
        { "font_style_property", reinterpret_cast<getter>(TextBlock_get_FontStyleProperty), nullptr, nullptr, nullptr },
        { "font_weight_property", reinterpret_cast<getter>(TextBlock_get_FontWeightProperty), nullptr, nullptr, nullptr },
        { "foreground_property", reinterpret_cast<getter>(TextBlock_get_ForegroundProperty), nullptr, nullptr, nullptr },
        { "horizontal_text_alignment_property", reinterpret_cast<getter>(TextBlock_get_HorizontalTextAlignmentProperty), nullptr, nullptr, nullptr },
        { "is_color_font_enabled_property", reinterpret_cast<getter>(TextBlock_get_IsColorFontEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_scale_factor_enabled_property", reinterpret_cast<getter>(TextBlock_get_IsTextScaleFactorEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_selection_enabled_property", reinterpret_cast<getter>(TextBlock_get_IsTextSelectionEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_trimmed_property", reinterpret_cast<getter>(TextBlock_get_IsTextTrimmedProperty), nullptr, nullptr, nullptr },
        { "line_height_property", reinterpret_cast<getter>(TextBlock_get_LineHeightProperty), nullptr, nullptr, nullptr },
        { "line_stacking_strategy_property", reinterpret_cast<getter>(TextBlock_get_LineStackingStrategyProperty), nullptr, nullptr, nullptr },
        { "max_lines_property", reinterpret_cast<getter>(TextBlock_get_MaxLinesProperty), nullptr, nullptr, nullptr },
        { "optical_margin_alignment_property", reinterpret_cast<getter>(TextBlock_get_OpticalMarginAlignmentProperty), nullptr, nullptr, nullptr },
        { "padding_property", reinterpret_cast<getter>(TextBlock_get_PaddingProperty), nullptr, nullptr, nullptr },
        { "selected_text_property", reinterpret_cast<getter>(TextBlock_get_SelectedTextProperty), nullptr, nullptr, nullptr },
        { "selection_flyout_property", reinterpret_cast<getter>(TextBlock_get_SelectionFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_property", reinterpret_cast<getter>(TextBlock_get_SelectionHighlightColorProperty), nullptr, nullptr, nullptr },
        { "text_alignment_property", reinterpret_cast<getter>(TextBlock_get_TextAlignmentProperty), nullptr, nullptr, nullptr },
        { "text_decorations_property", reinterpret_cast<getter>(TextBlock_get_TextDecorationsProperty), nullptr, nullptr, nullptr },
        { "text_line_bounds_property", reinterpret_cast<getter>(TextBlock_get_TextLineBoundsProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(TextBlock_get_TextProperty), nullptr, nullptr, nullptr },
        { "text_reading_order_property", reinterpret_cast<getter>(TextBlock_get_TextReadingOrderProperty), nullptr, nullptr, nullptr },
        { "text_trimming_property", reinterpret_cast<getter>(TextBlock_get_TextTrimmingProperty), nullptr, nullptr, nullptr },
        { "text_wrapping_property", reinterpret_cast<getter>(TextBlock_get_TextWrappingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TextBlock_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TextBlock_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TextBlock_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TextBlock_Static) },
        { }
    };

    static PyType_Spec type_spec_TextBlock_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextBlock_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TextBlock_Static
    };

    // ----- TextBox class --------------------

    static PyObject* _new_TextBox(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::Microsoft::UI::Xaml::Controls::TextBox 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_TextBox(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextBox_ClearUndoRedoHistory(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"ClearUndoRedoHistory", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.ClearUndoRedoHistory();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_CopySelectionToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CopySelectionToClipboard", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CopySelectionToClipboard();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_CutSelectionToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CutSelectionToClipboard", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CutSelectionToClipboard();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_GetLinguisticAlternativesAsync(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"GetLinguisticAlternativesAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetLinguisticAlternativesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_GetRectFromCharacterIndex(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"GetRectFromCharacterIndex", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                return py::convert(self->obj.GetRectFromCharacterIndex(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_PasteFromClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PasteFromClipboard", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.PasteFromClipboard();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_Redo(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Redo", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Redo();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_Select(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Select", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                self->obj.Select(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_Undo(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Undo", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Undo();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TextBox_get_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PlaceholderText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_PlaceholderText(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PlaceholderText"))
        {
            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.PlaceholderText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_PlaceholderForeground(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PlaceholderForeground"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlaceholderForeground());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_PlaceholderForeground(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PlaceholderForeground"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.PlaceholderForeground(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_MaxLength(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"MaxLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaxLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_MaxLength(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"MaxLength"))
        {
            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<int32_t>(arg);

            self->obj.MaxLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_IsTextPredictionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsTextPredictionEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsTextPredictionEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_IsTextPredictionEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsTextPredictionEnabled"))
        {
            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.IsTextPredictionEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_IsSpellCheckEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsSpellCheckEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsSpellCheckEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_IsSpellCheckEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsSpellCheckEnabled"))
        {
            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.IsSpellCheckEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_IsReadOnly(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsReadOnly"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsReadOnly());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_IsReadOnly(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsReadOnly"))
        {
            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.IsReadOnly(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsColorFontEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsColorFontEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_IsColorFontEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsColorFontEnabled"))
        {
            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.IsColorFontEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_InputScope(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"InputScope"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InputScope());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_InputScope(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"InputScope"))
        {
            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::Microsoft::UI::Xaml::Input::InputScope>(arg);

            self->obj.InputScope(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"HorizontalTextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalTextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_HorizontalTextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"HorizontalTextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.HorizontalTextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_DesiredCandidateWindowAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"DesiredCandidateWindowAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DesiredCandidateWindowAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_DesiredCandidateWindowAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"DesiredCandidateWindowAlignment"))
        {
            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::Microsoft::UI::Xaml::Controls::CandidateWindowAlignment>(arg);

            self->obj.DesiredCandidateWindowAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_Description(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Description"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Description());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_Description(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Description"))
        {
            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.Description(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_CharacterCasing(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CharacterCasing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CharacterCasing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_CharacterCasing(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CharacterCasing"))
        {
            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::Microsoft::UI::Xaml::Controls::CharacterCasing>(arg);

            self->obj.CharacterCasing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PreventKeyboardDisplayOnProgrammaticFocus());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_PreventKeyboardDisplayOnProgrammaticFocus(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PreventKeyboardDisplayOnProgrammaticFocus"))
        {
            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.PreventKeyboardDisplayOnProgrammaticFocus(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_AcceptsReturn(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"AcceptsReturn"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AcceptsReturn());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_AcceptsReturn(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"AcceptsReturn"))
        {
            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.AcceptsReturn(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_SelectedText(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectedText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_SelectedText(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectedText"))
        {
            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.SelectedText(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextWrapping"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextWrapping());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_TextWrapping(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextWrapping"))
        {
            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::Microsoft::UI::Xaml::TextWrapping>(arg);

            self->obj.TextWrapping(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextReadingOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextReadingOrder());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_TextReadingOrder(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextReadingOrder"))
        {
            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::Microsoft::UI::Xaml::TextReadingOrder>(arg);

            self->obj.TextReadingOrder(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TextAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_TextAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextAlignment"))
        {
            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::Microsoft::UI::Xaml::TextAlignment>(arg);

            self->obj.TextAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_Text(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Text"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Text());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_Text(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Text"))
        {
            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.Text(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_SelectionStart(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_SelectionStart(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionStart"))
        {
            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<int32_t>(arg);

            self->obj.SelectionStart(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_SelectionLength(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_SelectionLength(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionLength"))
        {
            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<int32_t>(arg);

            self->obj.SelectionLength(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_SelectionHighlightColorWhenNotFocused(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionHighlightColorWhenNotFocused"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColorWhenNotFocused());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_SelectionHighlightColorWhenNotFocused(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionHighlightColorWhenNotFocused"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColorWhenNotFocused(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionHighlightColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionHighlightColor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_SelectionHighlightColor(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionHighlightColor"))
        {
            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::Microsoft::UI::Xaml::Media::SolidColorBrush>(arg);

            self->obj.SelectionHighlightColor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBox_put_SelectionFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionFlyout"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::FlyoutBase>(arg);

            self->obj.SelectionFlyout(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBox_get_CanUndo(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CanUndo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanUndo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_CanRedo(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CanRedo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanRedo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_CanPasteClipboardContent(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CanPasteClipboardContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanPasteClipboardContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_ProofingMenuFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"ProofingMenuFlyout"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ProofingMenuFlyout());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_AcceptsReturnProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"AcceptsReturnProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::AcceptsReturnProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_CanPasteClipboardContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CanPasteClipboardContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::CanPasteClipboardContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_CanRedoProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CanRedoProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::CanRedoProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_CanUndoProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CanUndoProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::CanUndoProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_CharacterCasingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CharacterCasingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::CharacterCasingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_DescriptionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"DescriptionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::DescriptionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_DesiredCandidateWindowAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"DesiredCandidateWindowAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::DesiredCandidateWindowAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_HorizontalTextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"HorizontalTextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::HorizontalTextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_InputScopeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"InputScopeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::InputScopeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_IsColorFontEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsColorFontEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::IsColorFontEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_IsReadOnlyProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsReadOnlyProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::IsReadOnlyProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_IsSpellCheckEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsSpellCheckEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::IsSpellCheckEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_IsTextPredictionEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"IsTextPredictionEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::IsTextPredictionEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_MaxLengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"MaxLengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::MaxLengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_PlaceholderForegroundProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PlaceholderForegroundProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::PlaceholderForegroundProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_PlaceholderTextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PlaceholderTextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::PlaceholderTextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"PreventKeyboardDisplayOnProgrammaticFocusProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::PreventKeyboardDisplayOnProgrammaticFocusProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_ProofingMenuFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"ProofingMenuFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::ProofingMenuFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_SelectionFlyoutProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionFlyoutProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::SelectionFlyoutProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_SelectionHighlightColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionHighlightColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::SelectionHighlightColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_SelectionHighlightColorWhenNotFocusedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionHighlightColorWhenNotFocusedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::SelectionHighlightColorWhenNotFocusedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_TextAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::TextAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_TextProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::TextProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_TextReadingOrderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextReadingOrderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::TextReadingOrderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_get_TextWrappingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextWrappingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TextBox::TextWrappingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_BeforeTextChanging(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"BeforeTextChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs>>(arg);

            return py::convert(self->obj.BeforeTextChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_BeforeTextChanging(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"BeforeTextChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.BeforeTextChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_CandidateWindowBoundsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CandidateWindowBoundsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::CandidateWindowBoundsChangedEventArgs>>(arg);

            return py::convert(self->obj.CandidateWindowBoundsChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_CandidateWindowBoundsChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CandidateWindowBoundsChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CandidateWindowBoundsChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ContextMenuOpeningEventHandler>(arg);

            return py::convert(self->obj.ContextMenuOpening(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_ContextMenuOpening(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"ContextMenuOpening"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ContextMenuOpening(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_CopyingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CopyingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs>>(arg);

            return py::convert(self->obj.CopyingToClipboard(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_CopyingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CopyingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CopyingToClipboard(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_CuttingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CuttingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs>>(arg);

            return py::convert(self->obj.CuttingToClipboard(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_CuttingToClipboard(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"CuttingToClipboard"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CuttingToClipboard(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_Paste(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Paste"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::TextControlPasteEventHandler>(arg);

            return py::convert(self->obj.Paste(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_Paste(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"Paste"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Paste(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_SelectionChanging(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs>>(arg);

            return py::convert(self->obj.SelectionChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_SelectionChanging(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"SelectionChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_TextChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::TextChangedEventHandler>(arg);

            return py::convert(self->obj.TextChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_TextChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_TextChanging(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs>>(arg);

            return py::convert(self->obj.TextChanging(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_TextChanging(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextChanging(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_TextCompositionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextCompositionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs>>(arg);

            return py::convert(self->obj.TextCompositionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_TextCompositionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextCompositionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextCompositionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_TextCompositionEnded(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextCompositionEnded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs>>(arg);

            return py::convert(self->obj.TextCompositionEnded(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_TextCompositionEnded(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextCompositionEnded"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextCompositionEnded(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_add_TextCompositionStarted(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextCompositionStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TextBox, winrt::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs>>(arg);

            return py::convert(self->obj.TextCompositionStarted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBox_remove_TextCompositionStarted(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TextBox", L"TextCompositionStarted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TextCompositionStarted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextBox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextBox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextBox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextBox[] = {
        { "clear_undo_redo_history", reinterpret_cast<PyCFunction>(TextBox_ClearUndoRedoHistory), METH_VARARGS, nullptr },
        { "copy_selection_to_clipboard", reinterpret_cast<PyCFunction>(TextBox_CopySelectionToClipboard), METH_VARARGS, nullptr },
        { "cut_selection_to_clipboard", reinterpret_cast<PyCFunction>(TextBox_CutSelectionToClipboard), METH_VARARGS, nullptr },
        { "get_linguistic_alternatives_async", reinterpret_cast<PyCFunction>(TextBox_GetLinguisticAlternativesAsync), METH_VARARGS, nullptr },
        { "get_rect_from_character_index", reinterpret_cast<PyCFunction>(TextBox_GetRectFromCharacterIndex), METH_VARARGS, nullptr },
        { "paste_from_clipboard", reinterpret_cast<PyCFunction>(TextBox_PasteFromClipboard), METH_VARARGS, nullptr },
        { "redo", reinterpret_cast<PyCFunction>(TextBox_Redo), METH_VARARGS, nullptr },
        { "select", reinterpret_cast<PyCFunction>(TextBox_Select), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(TextBox_SelectAll), METH_VARARGS, nullptr },
        { "undo", reinterpret_cast<PyCFunction>(TextBox_Undo), METH_VARARGS, nullptr },
        { "add_before_text_changing", reinterpret_cast<PyCFunction>(TextBox_add_BeforeTextChanging), METH_O, nullptr },
        { "remove_before_text_changing", reinterpret_cast<PyCFunction>(TextBox_remove_BeforeTextChanging), METH_O, nullptr },
        { "add_candidate_window_bounds_changed", reinterpret_cast<PyCFunction>(TextBox_add_CandidateWindowBoundsChanged), METH_O, nullptr },
        { "remove_candidate_window_bounds_changed", reinterpret_cast<PyCFunction>(TextBox_remove_CandidateWindowBoundsChanged), METH_O, nullptr },
        { "add_context_menu_opening", reinterpret_cast<PyCFunction>(TextBox_add_ContextMenuOpening), METH_O, nullptr },
        { "remove_context_menu_opening", reinterpret_cast<PyCFunction>(TextBox_remove_ContextMenuOpening), METH_O, nullptr },
        { "add_copying_to_clipboard", reinterpret_cast<PyCFunction>(TextBox_add_CopyingToClipboard), METH_O, nullptr },
        { "remove_copying_to_clipboard", reinterpret_cast<PyCFunction>(TextBox_remove_CopyingToClipboard), METH_O, nullptr },
        { "add_cutting_to_clipboard", reinterpret_cast<PyCFunction>(TextBox_add_CuttingToClipboard), METH_O, nullptr },
        { "remove_cutting_to_clipboard", reinterpret_cast<PyCFunction>(TextBox_remove_CuttingToClipboard), METH_O, nullptr },
        { "add_paste", reinterpret_cast<PyCFunction>(TextBox_add_Paste), METH_O, nullptr },
        { "remove_paste", reinterpret_cast<PyCFunction>(TextBox_remove_Paste), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(TextBox_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(TextBox_remove_SelectionChanged), METH_O, nullptr },
        { "add_selection_changing", reinterpret_cast<PyCFunction>(TextBox_add_SelectionChanging), METH_O, nullptr },
        { "remove_selection_changing", reinterpret_cast<PyCFunction>(TextBox_remove_SelectionChanging), METH_O, nullptr },
        { "add_text_changed", reinterpret_cast<PyCFunction>(TextBox_add_TextChanged), METH_O, nullptr },
        { "remove_text_changed", reinterpret_cast<PyCFunction>(TextBox_remove_TextChanged), METH_O, nullptr },
        { "add_text_changing", reinterpret_cast<PyCFunction>(TextBox_add_TextChanging), METH_O, nullptr },
        { "remove_text_changing", reinterpret_cast<PyCFunction>(TextBox_remove_TextChanging), METH_O, nullptr },
        { "add_text_composition_changed", reinterpret_cast<PyCFunction>(TextBox_add_TextCompositionChanged), METH_O, nullptr },
        { "remove_text_composition_changed", reinterpret_cast<PyCFunction>(TextBox_remove_TextCompositionChanged), METH_O, nullptr },
        { "add_text_composition_ended", reinterpret_cast<PyCFunction>(TextBox_add_TextCompositionEnded), METH_O, nullptr },
        { "remove_text_composition_ended", reinterpret_cast<PyCFunction>(TextBox_remove_TextCompositionEnded), METH_O, nullptr },
        { "add_text_composition_started", reinterpret_cast<PyCFunction>(TextBox_add_TextCompositionStarted), METH_O, nullptr },
        { "remove_text_composition_started", reinterpret_cast<PyCFunction>(TextBox_remove_TextCompositionStarted), METH_O, nullptr },
        { "_assign_array_", _assign_array_TextBox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextBox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextBox[] = {
        { "placeholder_text", reinterpret_cast<getter>(TextBox_get_PlaceholderText), reinterpret_cast<setter>(TextBox_put_PlaceholderText), nullptr, nullptr },
        { "placeholder_foreground", reinterpret_cast<getter>(TextBox_get_PlaceholderForeground), reinterpret_cast<setter>(TextBox_put_PlaceholderForeground), nullptr, nullptr },
        { "max_length", reinterpret_cast<getter>(TextBox_get_MaxLength), reinterpret_cast<setter>(TextBox_put_MaxLength), nullptr, nullptr },
        { "is_text_prediction_enabled", reinterpret_cast<getter>(TextBox_get_IsTextPredictionEnabled), reinterpret_cast<setter>(TextBox_put_IsTextPredictionEnabled), nullptr, nullptr },
        { "is_spell_check_enabled", reinterpret_cast<getter>(TextBox_get_IsSpellCheckEnabled), reinterpret_cast<setter>(TextBox_put_IsSpellCheckEnabled), nullptr, nullptr },
        { "is_read_only", reinterpret_cast<getter>(TextBox_get_IsReadOnly), reinterpret_cast<setter>(TextBox_put_IsReadOnly), nullptr, nullptr },
        { "is_color_font_enabled", reinterpret_cast<getter>(TextBox_get_IsColorFontEnabled), reinterpret_cast<setter>(TextBox_put_IsColorFontEnabled), nullptr, nullptr },
        { "input_scope", reinterpret_cast<getter>(TextBox_get_InputScope), reinterpret_cast<setter>(TextBox_put_InputScope), nullptr, nullptr },
        { "horizontal_text_alignment", reinterpret_cast<getter>(TextBox_get_HorizontalTextAlignment), reinterpret_cast<setter>(TextBox_put_HorizontalTextAlignment), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(TextBox_get_HeaderTemplate), reinterpret_cast<setter>(TextBox_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(TextBox_get_Header), reinterpret_cast<setter>(TextBox_put_Header), nullptr, nullptr },
        { "desired_candidate_window_alignment", reinterpret_cast<getter>(TextBox_get_DesiredCandidateWindowAlignment), reinterpret_cast<setter>(TextBox_put_DesiredCandidateWindowAlignment), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(TextBox_get_Description), reinterpret_cast<setter>(TextBox_put_Description), nullptr, nullptr },
        { "character_casing", reinterpret_cast<getter>(TextBox_get_CharacterCasing), reinterpret_cast<setter>(TextBox_put_CharacterCasing), nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus", reinterpret_cast<getter>(TextBox_get_PreventKeyboardDisplayOnProgrammaticFocus), reinterpret_cast<setter>(TextBox_put_PreventKeyboardDisplayOnProgrammaticFocus), nullptr, nullptr },
        { "accepts_return", reinterpret_cast<getter>(TextBox_get_AcceptsReturn), reinterpret_cast<setter>(TextBox_put_AcceptsReturn), nullptr, nullptr },
        { "selected_text", reinterpret_cast<getter>(TextBox_get_SelectedText), reinterpret_cast<setter>(TextBox_put_SelectedText), nullptr, nullptr },
        { "text_wrapping", reinterpret_cast<getter>(TextBox_get_TextWrapping), reinterpret_cast<setter>(TextBox_put_TextWrapping), nullptr, nullptr },
        { "text_reading_order", reinterpret_cast<getter>(TextBox_get_TextReadingOrder), reinterpret_cast<setter>(TextBox_put_TextReadingOrder), nullptr, nullptr },
        { "text_alignment", reinterpret_cast<getter>(TextBox_get_TextAlignment), reinterpret_cast<setter>(TextBox_put_TextAlignment), nullptr, nullptr },
        { "text", reinterpret_cast<getter>(TextBox_get_Text), reinterpret_cast<setter>(TextBox_put_Text), nullptr, nullptr },
        { "selection_start", reinterpret_cast<getter>(TextBox_get_SelectionStart), reinterpret_cast<setter>(TextBox_put_SelectionStart), nullptr, nullptr },
        { "selection_length", reinterpret_cast<getter>(TextBox_get_SelectionLength), reinterpret_cast<setter>(TextBox_put_SelectionLength), nullptr, nullptr },
        { "selection_highlight_color_when_not_focused", reinterpret_cast<getter>(TextBox_get_SelectionHighlightColorWhenNotFocused), reinterpret_cast<setter>(TextBox_put_SelectionHighlightColorWhenNotFocused), nullptr, nullptr },
        { "selection_highlight_color", reinterpret_cast<getter>(TextBox_get_SelectionHighlightColor), reinterpret_cast<setter>(TextBox_put_SelectionHighlightColor), nullptr, nullptr },
        { "selection_flyout", reinterpret_cast<getter>(TextBox_get_SelectionFlyout), reinterpret_cast<setter>(TextBox_put_SelectionFlyout), nullptr, nullptr },
        { "can_undo", reinterpret_cast<getter>(TextBox_get_CanUndo), nullptr, nullptr, nullptr },
        { "can_redo", reinterpret_cast<getter>(TextBox_get_CanRedo), nullptr, nullptr, nullptr },
        { "can_paste_clipboard_content", reinterpret_cast<getter>(TextBox_get_CanPasteClipboardContent), nullptr, nullptr, nullptr },
        { "proofing_menu_flyout", reinterpret_cast<getter>(TextBox_get_ProofingMenuFlyout), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextBox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextBox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextBox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextBox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextBox) },
        { },
    };

    static PyType_Spec type_spec_TextBox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextBox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextBox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextBox
    };

    static PyGetSetDef getset_TextBox_Static[] = {
        { "accepts_return_property", reinterpret_cast<getter>(TextBox_get_AcceptsReturnProperty), nullptr, nullptr, nullptr },
        { "can_paste_clipboard_content_property", reinterpret_cast<getter>(TextBox_get_CanPasteClipboardContentProperty), nullptr, nullptr, nullptr },
        { "can_redo_property", reinterpret_cast<getter>(TextBox_get_CanRedoProperty), nullptr, nullptr, nullptr },
        { "can_undo_property", reinterpret_cast<getter>(TextBox_get_CanUndoProperty), nullptr, nullptr, nullptr },
        { "character_casing_property", reinterpret_cast<getter>(TextBox_get_CharacterCasingProperty), nullptr, nullptr, nullptr },
        { "description_property", reinterpret_cast<getter>(TextBox_get_DescriptionProperty), nullptr, nullptr, nullptr },
        { "desired_candidate_window_alignment_property", reinterpret_cast<getter>(TextBox_get_DesiredCandidateWindowAlignmentProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(TextBox_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(TextBox_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "horizontal_text_alignment_property", reinterpret_cast<getter>(TextBox_get_HorizontalTextAlignmentProperty), nullptr, nullptr, nullptr },
        { "input_scope_property", reinterpret_cast<getter>(TextBox_get_InputScopeProperty), nullptr, nullptr, nullptr },
        { "is_color_font_enabled_property", reinterpret_cast<getter>(TextBox_get_IsColorFontEnabledProperty), nullptr, nullptr, nullptr },
        { "is_read_only_property", reinterpret_cast<getter>(TextBox_get_IsReadOnlyProperty), nullptr, nullptr, nullptr },
        { "is_spell_check_enabled_property", reinterpret_cast<getter>(TextBox_get_IsSpellCheckEnabledProperty), nullptr, nullptr, nullptr },
        { "is_text_prediction_enabled_property", reinterpret_cast<getter>(TextBox_get_IsTextPredictionEnabledProperty), nullptr, nullptr, nullptr },
        { "max_length_property", reinterpret_cast<getter>(TextBox_get_MaxLengthProperty), nullptr, nullptr, nullptr },
        { "placeholder_foreground_property", reinterpret_cast<getter>(TextBox_get_PlaceholderForegroundProperty), nullptr, nullptr, nullptr },
        { "placeholder_text_property", reinterpret_cast<getter>(TextBox_get_PlaceholderTextProperty), nullptr, nullptr, nullptr },
        { "prevent_keyboard_display_on_programmatic_focus_property", reinterpret_cast<getter>(TextBox_get_PreventKeyboardDisplayOnProgrammaticFocusProperty), nullptr, nullptr, nullptr },
        { "proofing_menu_flyout_property", reinterpret_cast<getter>(TextBox_get_ProofingMenuFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_flyout_property", reinterpret_cast<getter>(TextBox_get_SelectionFlyoutProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_property", reinterpret_cast<getter>(TextBox_get_SelectionHighlightColorProperty), nullptr, nullptr, nullptr },
        { "selection_highlight_color_when_not_focused_property", reinterpret_cast<getter>(TextBox_get_SelectionHighlightColorWhenNotFocusedProperty), nullptr, nullptr, nullptr },
        { "text_alignment_property", reinterpret_cast<getter>(TextBox_get_TextAlignmentProperty), nullptr, nullptr, nullptr },
        { "text_property", reinterpret_cast<getter>(TextBox_get_TextProperty), nullptr, nullptr, nullptr },
        { "text_reading_order_property", reinterpret_cast<getter>(TextBox_get_TextReadingOrderProperty), nullptr, nullptr, nullptr },
        { "text_wrapping_property", reinterpret_cast<getter>(TextBox_get_TextWrappingProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TextBox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TextBox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TextBox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TextBox_Static) },
        { }
    };

    static PyType_Spec type_spec_TextBox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextBox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TextBox_Static
    };

    // ----- TextBoxBeforeTextChangingEventArgs class --------------------

    static PyObject* _new_TextBoxBeforeTextChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextBoxBeforeTextChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextBoxBeforeTextChangingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBoxBeforeTextChangingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBoxBeforeTextChangingEventArgs_get_NewText(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs", L"NewText"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewText());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextBoxBeforeTextChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextBoxBeforeTextChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextBoxBeforeTextChangingEventArgs[] = {
        { "_assign_array_", _assign_array_TextBoxBeforeTextChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextBoxBeforeTextChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextBoxBeforeTextChangingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(TextBoxBeforeTextChangingEventArgs_get_Cancel), reinterpret_cast<setter>(TextBoxBeforeTextChangingEventArgs_put_Cancel), nullptr, nullptr },
        { "new_text", reinterpret_cast<getter>(TextBoxBeforeTextChangingEventArgs_get_NewText), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextBoxBeforeTextChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextBoxBeforeTextChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextBoxBeforeTextChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextBoxBeforeTextChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextBoxBeforeTextChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextBoxBeforeTextChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextBoxBeforeTextChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxBeforeTextChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextBoxBeforeTextChangingEventArgs
    };

    // ----- TextBoxSelectionChangingEventArgs class --------------------

    static PyObject* _new_TextBoxSelectionChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextBoxSelectionChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextBoxSelectionChangingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextBoxSelectionChangingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TextBoxSelectionChangingEventArgs_get_SelectionLength(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs", L"SelectionLength"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionLength());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TextBoxSelectionChangingEventArgs_get_SelectionStart(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs", L"SelectionStart"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionStart());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextBoxSelectionChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextBoxSelectionChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextBoxSelectionChangingEventArgs[] = {
        { "_assign_array_", _assign_array_TextBoxSelectionChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextBoxSelectionChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextBoxSelectionChangingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(TextBoxSelectionChangingEventArgs_get_Cancel), reinterpret_cast<setter>(TextBoxSelectionChangingEventArgs_put_Cancel), nullptr, nullptr },
        { "selection_length", reinterpret_cast<getter>(TextBoxSelectionChangingEventArgs_get_SelectionLength), nullptr, nullptr, nullptr },
        { "selection_start", reinterpret_cast<getter>(TextBoxSelectionChangingEventArgs_get_SelectionStart), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextBoxSelectionChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextBoxSelectionChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextBoxSelectionChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextBoxSelectionChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextBoxSelectionChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextBoxSelectionChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextBoxSelectionChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxSelectionChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextBoxSelectionChangingEventArgs
    };

    // ----- TextBoxTextChangingEventArgs class --------------------

    static PyObject* _new_TextBoxTextChangingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextBoxTextChangingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextBoxTextChangingEventArgs_get_IsContentChanging(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextBoxTextChangingEventArgs", L"IsContentChanging"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsContentChanging());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextBoxTextChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextBoxTextChangingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextBoxTextChangingEventArgs[] = {
        { "_assign_array_", _assign_array_TextBoxTextChangingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextBoxTextChangingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextBoxTextChangingEventArgs[] = {
        { "is_content_changing", reinterpret_cast<getter>(TextBoxTextChangingEventArgs_get_IsContentChanging), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextBoxTextChangingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextBoxTextChangingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextBoxTextChangingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextBoxTextChangingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextBoxTextChangingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextBoxTextChangingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextBoxTextChangingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextBoxTextChangingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextBoxTextChangingEventArgs
    };

    // ----- TextChangedEventArgs class --------------------

    static PyObject* _new_TextChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_TextChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextChangedEventArgs[] = {
        { "_assign_array_", _assign_array_TextChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextChangedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_TextChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextChangedEventArgs
    };

    // ----- TextCommandBarFlyout class --------------------

    static PyObject* _new_TextCommandBarFlyout(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::Microsoft::UI::Xaml::Controls::TextCommandBarFlyout 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_TextCommandBarFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::TextCommandBarFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_TextCommandBarFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextCommandBarFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextCommandBarFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextCommandBarFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextCommandBarFlyout[] = {
        { "_assign_array_", _assign_array_TextCommandBarFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextCommandBarFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextCommandBarFlyout[] = {
        { }
    };

    static PyType_Slot _type_slots_TextCommandBarFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextCommandBarFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextCommandBarFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextCommandBarFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextCommandBarFlyout) },
        { },
    };

    static PyType_Spec type_spec_TextCommandBarFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextCommandBarFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextCommandBarFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextCommandBarFlyout
    };

    // ----- TextCompositionChangedEventArgs class --------------------

    static PyObject* _new_TextCompositionChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextCompositionChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextCompositionChangedEventArgs_get_Length(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextCompositionChangedEventArgs", 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* TextCompositionChangedEventArgs_get_StartIndex(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextCompositionChangedEventArgs", L"StartIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.StartIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextCompositionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextCompositionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextCompositionChangedEventArgs[] = {
        { "_assign_array_", _assign_array_TextCompositionChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextCompositionChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextCompositionChangedEventArgs[] = {
        { "length", reinterpret_cast<getter>(TextCompositionChangedEventArgs_get_Length), nullptr, nullptr, nullptr },
        { "start_index", reinterpret_cast<getter>(TextCompositionChangedEventArgs_get_StartIndex), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextCompositionChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextCompositionChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextCompositionChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextCompositionChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextCompositionChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextCompositionChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextCompositionChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextCompositionChangedEventArgs
    };

    // ----- TextCompositionEndedEventArgs class --------------------

    static PyObject* _new_TextCompositionEndedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextCompositionEndedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextCompositionEndedEventArgs_get_Length(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextCompositionEndedEventArgs", 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* TextCompositionEndedEventArgs_get_StartIndex(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextCompositionEndedEventArgs", L"StartIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.StartIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextCompositionEndedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextCompositionEndedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextCompositionEndedEventArgs[] = {
        { "_assign_array_", _assign_array_TextCompositionEndedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextCompositionEndedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextCompositionEndedEventArgs[] = {
        { "length", reinterpret_cast<getter>(TextCompositionEndedEventArgs_get_Length), nullptr, nullptr, nullptr },
        { "start_index", reinterpret_cast<getter>(TextCompositionEndedEventArgs_get_StartIndex), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextCompositionEndedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextCompositionEndedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextCompositionEndedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextCompositionEndedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextCompositionEndedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextCompositionEndedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextCompositionEndedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionEndedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextCompositionEndedEventArgs
    };

    // ----- TextCompositionStartedEventArgs class --------------------

    static PyObject* _new_TextCompositionStartedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextCompositionStartedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextCompositionStartedEventArgs_get_Length(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextCompositionStartedEventArgs", 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* TextCompositionStartedEventArgs_get_StartIndex(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextCompositionStartedEventArgs", L"StartIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.StartIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TextCompositionStartedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextCompositionStartedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextCompositionStartedEventArgs[] = {
        { "_assign_array_", _assign_array_TextCompositionStartedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextCompositionStartedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextCompositionStartedEventArgs[] = {
        { "length", reinterpret_cast<getter>(TextCompositionStartedEventArgs_get_Length), nullptr, nullptr, nullptr },
        { "start_index", reinterpret_cast<getter>(TextCompositionStartedEventArgs_get_StartIndex), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextCompositionStartedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextCompositionStartedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextCompositionStartedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextCompositionStartedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextCompositionStartedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextCompositionStartedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextCompositionStartedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextCompositionStartedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextCompositionStartedEventArgs
    };

    // ----- TextControlCopyingToClipboardEventArgs class --------------------

    static PyObject* _new_TextControlCopyingToClipboardEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextControlCopyingToClipboardEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextControlCopyingToClipboardEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Handled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextControlCopyingToClipboardEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_TextControlCopyingToClipboardEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextControlCopyingToClipboardEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextControlCopyingToClipboardEventArgs[] = {
        { "_assign_array_", _assign_array_TextControlCopyingToClipboardEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextControlCopyingToClipboardEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextControlCopyingToClipboardEventArgs[] = {
        { "handled", reinterpret_cast<getter>(TextControlCopyingToClipboardEventArgs_get_Handled), reinterpret_cast<setter>(TextControlCopyingToClipboardEventArgs_put_Handled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextControlCopyingToClipboardEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextControlCopyingToClipboardEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextControlCopyingToClipboardEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextControlCopyingToClipboardEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextControlCopyingToClipboardEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextControlCopyingToClipboardEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextControlCopyingToClipboardEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCopyingToClipboardEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextControlCopyingToClipboardEventArgs
    };

    // ----- TextControlCuttingToClipboardEventArgs class --------------------

    static PyObject* _new_TextControlCuttingToClipboardEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextControlCuttingToClipboardEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextControlCuttingToClipboardEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Handled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextControlCuttingToClipboardEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_TextControlCuttingToClipboardEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextControlCuttingToClipboardEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextControlCuttingToClipboardEventArgs[] = {
        { "_assign_array_", _assign_array_TextControlCuttingToClipboardEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextControlCuttingToClipboardEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextControlCuttingToClipboardEventArgs[] = {
        { "handled", reinterpret_cast<getter>(TextControlCuttingToClipboardEventArgs_get_Handled), reinterpret_cast<setter>(TextControlCuttingToClipboardEventArgs_put_Handled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextControlCuttingToClipboardEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextControlCuttingToClipboardEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextControlCuttingToClipboardEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextControlCuttingToClipboardEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextControlCuttingToClipboardEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextControlCuttingToClipboardEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextControlCuttingToClipboardEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlCuttingToClipboardEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextControlCuttingToClipboardEventArgs
    };

    // ----- TextControlPasteEventArgs class --------------------

    static PyObject* _new_TextControlPasteEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TextControlPasteEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TextControlPasteEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextControlPasteEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Handled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TextControlPasteEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TextControlPasteEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_TextControlPasteEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TextControlPasteEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TextControlPasteEventArgs[] = {
        { "_assign_array_", _assign_array_TextControlPasteEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TextControlPasteEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TextControlPasteEventArgs[] = {
        { "handled", reinterpret_cast<getter>(TextControlPasteEventArgs_get_Handled), reinterpret_cast<setter>(TextControlPasteEventArgs_put_Handled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TextControlPasteEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TextControlPasteEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TextControlPasteEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TextControlPasteEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TextControlPasteEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TextControlPasteEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TextControlPasteEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TextControlPasteEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TextControlPasteEventArgs
    };

    // ----- TimePickedEventArgs class --------------------

    static PyObject* _new_TimePickedEventArgs(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::Microsoft::UI::Xaml::Controls::TimePickedEventArgs 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_TimePickedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TimePickedEventArgs_get_NewTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickedEventArgs", L"NewTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePickedEventArgs_get_OldTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickedEventArgs", L"OldTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OldTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TimePickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TimePickedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TimePickedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TimePickedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TimePickedEventArgs[] = {
        { "_assign_array_", _assign_array_TimePickedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TimePickedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TimePickedEventArgs[] = {
        { "new_time", reinterpret_cast<getter>(TimePickedEventArgs_get_NewTime), nullptr, nullptr, nullptr },
        { "old_time", reinterpret_cast<getter>(TimePickedEventArgs_get_OldTime), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TimePickedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TimePickedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TimePickedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TimePickedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TimePickedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TimePickedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePickedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TimePickedEventArgs
    };

    // ----- TimePicker class --------------------

    static PyObject* _new_TimePicker(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::Microsoft::UI::Xaml::Controls::TimePicker 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_TimePicker(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TimePicker_get_Time(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"Time"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Time());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePicker_put_Time(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"Time"))
        {
            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::TimeSpan>(arg);

            self->obj.Time(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePicker_get_SelectedTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"SelectedTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePicker_put_SelectedTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"SelectedTime"))
        {
            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::IReference<winrt::Windows::Foundation::TimeSpan>>(arg);

            self->obj.SelectedTime(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePicker_get_MinuteIncrement(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"MinuteIncrement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinuteIncrement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePicker_put_MinuteIncrement(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"MinuteIncrement"))
        {
            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<int32_t>(arg);

            self->obj.MinuteIncrement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePicker_get_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"LightDismissOverlayMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LightDismissOverlayMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePicker_put_LightDismissOverlayMode(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"LightDismissOverlayMode"))
        {
            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::Microsoft::UI::Xaml::Controls::LightDismissOverlayMode>(arg);

            self->obj.LightDismissOverlayMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePicker_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePicker_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePicker_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePicker_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePicker_get_ClockIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"ClockIdentifier"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ClockIdentifier());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePicker_put_ClockIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"ClockIdentifier"))
        {
            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.ClockIdentifier(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePicker_get_ClockIdentifierProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"ClockIdentifierProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePicker::ClockIdentifierProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePicker::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePicker::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_get_LightDismissOverlayModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"LightDismissOverlayModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePicker::LightDismissOverlayModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_get_MinuteIncrementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"MinuteIncrementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePicker::MinuteIncrementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_get_SelectedTimeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"SelectedTimeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePicker::SelectedTimeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_get_TimeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"TimeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePicker::TimeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_add_SelectedTimeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"SelectedTimeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TimePicker, winrt::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs>>(arg);

            return py::convert(self->obj.SelectedTimeChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_remove_SelectedTimeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"SelectedTimeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectedTimeChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_add_TimeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"TimeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs>>(arg);

            return py::convert(self->obj.TimeChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePicker_remove_TimeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TimePicker", L"TimeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TimeChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TimePicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TimePicker>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TimePicker(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TimePicker>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TimePicker[] = {
        { "add_selected_time_changed", reinterpret_cast<PyCFunction>(TimePicker_add_SelectedTimeChanged), METH_O, nullptr },
        { "remove_selected_time_changed", reinterpret_cast<PyCFunction>(TimePicker_remove_SelectedTimeChanged), METH_O, nullptr },
        { "add_time_changed", reinterpret_cast<PyCFunction>(TimePicker_add_TimeChanged), METH_O, nullptr },
        { "remove_time_changed", reinterpret_cast<PyCFunction>(TimePicker_remove_TimeChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_TimePicker, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TimePicker), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TimePicker[] = {
        { "time", reinterpret_cast<getter>(TimePicker_get_Time), reinterpret_cast<setter>(TimePicker_put_Time), nullptr, nullptr },
        { "selected_time", reinterpret_cast<getter>(TimePicker_get_SelectedTime), reinterpret_cast<setter>(TimePicker_put_SelectedTime), nullptr, nullptr },
        { "minute_increment", reinterpret_cast<getter>(TimePicker_get_MinuteIncrement), reinterpret_cast<setter>(TimePicker_put_MinuteIncrement), nullptr, nullptr },
        { "light_dismiss_overlay_mode", reinterpret_cast<getter>(TimePicker_get_LightDismissOverlayMode), reinterpret_cast<setter>(TimePicker_put_LightDismissOverlayMode), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(TimePicker_get_HeaderTemplate), reinterpret_cast<setter>(TimePicker_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(TimePicker_get_Header), reinterpret_cast<setter>(TimePicker_put_Header), nullptr, nullptr },
        { "clock_identifier", reinterpret_cast<getter>(TimePicker_get_ClockIdentifier), reinterpret_cast<setter>(TimePicker_put_ClockIdentifier), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TimePicker[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TimePicker) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TimePicker) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TimePicker) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TimePicker) },
        { },
    };

    static PyType_Spec type_spec_TimePicker =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePicker",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TimePicker),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TimePicker
    };

    static PyGetSetDef getset_TimePicker_Static[] = {
        { "clock_identifier_property", reinterpret_cast<getter>(TimePicker_get_ClockIdentifierProperty), nullptr, nullptr, nullptr },
        { "header_property", reinterpret_cast<getter>(TimePicker_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(TimePicker_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "light_dismiss_overlay_mode_property", reinterpret_cast<getter>(TimePicker_get_LightDismissOverlayModeProperty), nullptr, nullptr, nullptr },
        { "minute_increment_property", reinterpret_cast<getter>(TimePicker_get_MinuteIncrementProperty), nullptr, nullptr, nullptr },
        { "selected_time_property", reinterpret_cast<getter>(TimePicker_get_SelectedTimeProperty), nullptr, nullptr, nullptr },
        { "time_property", reinterpret_cast<getter>(TimePicker_get_TimeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TimePicker_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TimePicker_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TimePicker_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TimePicker_Static) },
        { }
    };

    static PyType_Spec type_spec_TimePicker_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePicker_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TimePicker_Static
    };

    // ----- TimePickerFlyout class --------------------

    static PyObject* _new_TimePickerFlyout(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::Microsoft::UI::Xaml::Controls::TimePickerFlyout 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_TimePickerFlyout(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TimePickerFlyout_ShowAtAsync(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"ShowAtAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::FrameworkElement>(args, 0);

                return py::convert(self->obj.ShowAtAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TimePickerFlyout_get_Time(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"Time"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Time());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePickerFlyout_put_Time(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"Time"))
        {
            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::TimeSpan>(arg);

            self->obj.Time(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePickerFlyout_get_MinuteIncrement(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"MinuteIncrement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinuteIncrement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePickerFlyout_put_MinuteIncrement(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"MinuteIncrement"))
        {
            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<int32_t>(arg);

            self->obj.MinuteIncrement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePickerFlyout_get_ClockIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"ClockIdentifier"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ClockIdentifier());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePickerFlyout_put_ClockIdentifier(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"ClockIdentifier"))
        {
            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.ClockIdentifier(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePickerFlyout_get_ClockIdentifierProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"ClockIdentifierProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyout::ClockIdentifierProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePickerFlyout_get_MinuteIncrementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"MinuteIncrementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyout::MinuteIncrementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePickerFlyout_get_TimeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"TimeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyout::TimeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePickerFlyout_add_TimePicked(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"TimePicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyout, winrt::Microsoft::UI::Xaml::Controls::TimePickedEventArgs>>(arg);

            return py::convert(self->obj.TimePicked(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePickerFlyout_remove_TimePicked(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyout", L"TimePicked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.TimePicked(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TimePickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TimePickerFlyout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TimePickerFlyout[] = {
        { "show_at_async", reinterpret_cast<PyCFunction>(TimePickerFlyout_ShowAtAsync), METH_VARARGS, nullptr },
        { "add_time_picked", reinterpret_cast<PyCFunction>(TimePickerFlyout_add_TimePicked), METH_O, nullptr },
        { "remove_time_picked", reinterpret_cast<PyCFunction>(TimePickerFlyout_remove_TimePicked), METH_O, nullptr },
        { "_assign_array_", _assign_array_TimePickerFlyout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TimePickerFlyout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TimePickerFlyout[] = {
        { "time", reinterpret_cast<getter>(TimePickerFlyout_get_Time), reinterpret_cast<setter>(TimePickerFlyout_put_Time), nullptr, nullptr },
        { "minute_increment", reinterpret_cast<getter>(TimePickerFlyout_get_MinuteIncrement), reinterpret_cast<setter>(TimePickerFlyout_put_MinuteIncrement), nullptr, nullptr },
        { "clock_identifier", reinterpret_cast<getter>(TimePickerFlyout_get_ClockIdentifier), reinterpret_cast<setter>(TimePickerFlyout_put_ClockIdentifier), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TimePickerFlyout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TimePickerFlyout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TimePickerFlyout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TimePickerFlyout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TimePickerFlyout) },
        { },
    };

    static PyType_Spec type_spec_TimePickerFlyout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePickerFlyout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TimePickerFlyout
    };

    static PyGetSetDef getset_TimePickerFlyout_Static[] = {
        { "clock_identifier_property", reinterpret_cast<getter>(TimePickerFlyout_get_ClockIdentifierProperty), nullptr, nullptr, nullptr },
        { "minute_increment_property", reinterpret_cast<getter>(TimePickerFlyout_get_MinuteIncrementProperty), nullptr, nullptr, nullptr },
        { "time_property", reinterpret_cast<getter>(TimePickerFlyout_get_TimeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TimePickerFlyout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TimePickerFlyout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TimePickerFlyout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TimePickerFlyout_Static) },
        { }
    };

    static PyType_Spec type_spec_TimePickerFlyout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePickerFlyout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TimePickerFlyout_Static
    };

    // ----- TimePickerFlyoutPresenter class --------------------

    static PyObject* _new_TimePickerFlyoutPresenter(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter>::type_name);
        return nullptr;
    }

    static void _dealloc_TimePickerFlyoutPresenter(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TimePickerFlyoutPresenter_get_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsDefaultShadowEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TimePickerFlyoutPresenter_put_IsDefaultShadowEnabled(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyoutPresenter", L"IsDefaultShadowEnabled"))
        {
            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.IsDefaultShadowEnabled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TimePickerFlyoutPresenter_get_IsDefaultShadowEnabledProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerFlyoutPresenter", L"IsDefaultShadowEnabledProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter::IsDefaultShadowEnabledProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TimePickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TimePickerFlyoutPresenter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TimePickerFlyoutPresenter[] = {
        { "_assign_array_", _assign_array_TimePickerFlyoutPresenter, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TimePickerFlyoutPresenter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TimePickerFlyoutPresenter[] = {
        { "is_default_shadow_enabled", reinterpret_cast<getter>(TimePickerFlyoutPresenter_get_IsDefaultShadowEnabled), reinterpret_cast<setter>(TimePickerFlyoutPresenter_put_IsDefaultShadowEnabled), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TimePickerFlyoutPresenter[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TimePickerFlyoutPresenter) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TimePickerFlyoutPresenter) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TimePickerFlyoutPresenter) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TimePickerFlyoutPresenter) },
        { },
    };

    static PyType_Spec type_spec_TimePickerFlyoutPresenter =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePickerFlyoutPresenter",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerFlyoutPresenter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TimePickerFlyoutPresenter
    };

    static PyGetSetDef getset_TimePickerFlyoutPresenter_Static[] = {
        { "is_default_shadow_enabled_property", reinterpret_cast<getter>(TimePickerFlyoutPresenter_get_IsDefaultShadowEnabledProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TimePickerFlyoutPresenter_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TimePickerFlyoutPresenter_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TimePickerFlyoutPresenter_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TimePickerFlyoutPresenter_Static) },
        { }
    };

    static PyType_Spec type_spec_TimePickerFlyoutPresenter_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePickerFlyoutPresenter_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TimePickerFlyoutPresenter_Static
    };

    // ----- TimePickerSelectedValueChangedEventArgs class --------------------

    static PyObject* _new_TimePickerSelectedValueChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TimePickerSelectedValueChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TimePickerSelectedValueChangedEventArgs_get_NewTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs", L"NewTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePickerSelectedValueChangedEventArgs_get_OldTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs", L"OldTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OldTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TimePickerSelectedValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TimePickerSelectedValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TimePickerSelectedValueChangedEventArgs[] = {
        { "_assign_array_", _assign_array_TimePickerSelectedValueChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TimePickerSelectedValueChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TimePickerSelectedValueChangedEventArgs[] = {
        { "new_time", reinterpret_cast<getter>(TimePickerSelectedValueChangedEventArgs_get_NewTime), nullptr, nullptr, nullptr },
        { "old_time", reinterpret_cast<getter>(TimePickerSelectedValueChangedEventArgs_get_OldTime), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TimePickerSelectedValueChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TimePickerSelectedValueChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TimePickerSelectedValueChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TimePickerSelectedValueChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TimePickerSelectedValueChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TimePickerSelectedValueChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePickerSelectedValueChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerSelectedValueChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TimePickerSelectedValueChangedEventArgs
    };

    // ----- TimePickerValueChangedEventArgs class --------------------

    static PyObject* _new_TimePickerValueChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TimePickerValueChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TimePickerValueChangedEventArgs_get_NewTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerValueChangedEventArgs", L"NewTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TimePickerValueChangedEventArgs_get_OldTime(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TimePickerValueChangedEventArgs", L"OldTime"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OldTime());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TimePickerValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TimePickerValueChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TimePickerValueChangedEventArgs[] = {
        { "_assign_array_", _assign_array_TimePickerValueChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TimePickerValueChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TimePickerValueChangedEventArgs[] = {
        { "new_time", reinterpret_cast<getter>(TimePickerValueChangedEventArgs_get_NewTime), nullptr, nullptr, nullptr },
        { "old_time", reinterpret_cast<getter>(TimePickerValueChangedEventArgs_get_OldTime), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TimePickerValueChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TimePickerValueChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TimePickerValueChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TimePickerValueChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TimePickerValueChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TimePickerValueChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TimePickerValueChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TimePickerValueChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TimePickerValueChangedEventArgs
    };

    // ----- ToggleMenuFlyoutItem class --------------------

    static PyObject* _new_ToggleMenuFlyoutItem(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::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem 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_ToggleMenuFlyoutItem(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ToggleMenuFlyoutItem_get_IsChecked(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleMenuFlyoutItem", L"IsChecked"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsChecked());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleMenuFlyoutItem_put_IsChecked(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleMenuFlyoutItem", L"IsChecked"))
        {
            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.IsChecked(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleMenuFlyoutItem_get_IsCheckedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleMenuFlyoutItem", L"IsCheckedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem::IsCheckedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ToggleMenuFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ToggleMenuFlyoutItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ToggleMenuFlyoutItem[] = {
        { "_assign_array_", _assign_array_ToggleMenuFlyoutItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ToggleMenuFlyoutItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ToggleMenuFlyoutItem[] = {
        { "is_checked", reinterpret_cast<getter>(ToggleMenuFlyoutItem_get_IsChecked), reinterpret_cast<setter>(ToggleMenuFlyoutItem_put_IsChecked), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ToggleMenuFlyoutItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ToggleMenuFlyoutItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ToggleMenuFlyoutItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ToggleMenuFlyoutItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ToggleMenuFlyoutItem) },
        { },
    };

    static PyType_Spec type_spec_ToggleMenuFlyoutItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToggleMenuFlyoutItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleMenuFlyoutItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ToggleMenuFlyoutItem
    };

    static PyGetSetDef getset_ToggleMenuFlyoutItem_Static[] = {
        { "is_checked_property", reinterpret_cast<getter>(ToggleMenuFlyoutItem_get_IsCheckedProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ToggleMenuFlyoutItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ToggleMenuFlyoutItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ToggleMenuFlyoutItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ToggleMenuFlyoutItem_Static) },
        { }
    };

    static PyType_Spec type_spec_ToggleMenuFlyoutItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToggleMenuFlyoutItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ToggleMenuFlyoutItem_Static
    };

    // ----- ToggleSplitButton class --------------------

    static PyObject* _new_ToggleSplitButton(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::Microsoft::UI::Xaml::Controls::ToggleSplitButton 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_ToggleSplitButton(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButton* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ToggleSplitButton_get_IsChecked(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButton* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSplitButton", L"IsChecked"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsChecked());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSplitButton_put_IsChecked(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButton* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSplitButton", L"IsChecked"))
        {
            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.IsChecked(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSplitButton_get_IsCheckedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSplitButton", L"IsCheckedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButton::IsCheckedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSplitButton_add_IsCheckedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButton* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToggleSplitButton", L"IsCheckedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButton, winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButtonIsCheckedChangedEventArgs>>(arg);

            return py::convert(self->obj.IsCheckedChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSplitButton_remove_IsCheckedChanged(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButton* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToggleSplitButton", L"IsCheckedChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.IsCheckedChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ToggleSplitButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButton>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ToggleSplitButton(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButton>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ToggleSplitButton[] = {
        { "add_is_checked_changed", reinterpret_cast<PyCFunction>(ToggleSplitButton_add_IsCheckedChanged), METH_O, nullptr },
        { "remove_is_checked_changed", reinterpret_cast<PyCFunction>(ToggleSplitButton_remove_IsCheckedChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_ToggleSplitButton, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ToggleSplitButton), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ToggleSplitButton[] = {
        { "is_checked", reinterpret_cast<getter>(ToggleSplitButton_get_IsChecked), reinterpret_cast<setter>(ToggleSplitButton_put_IsChecked), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ToggleSplitButton[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ToggleSplitButton) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ToggleSplitButton) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ToggleSplitButton) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ToggleSplitButton) },
        { },
    };

    static PyType_Spec type_spec_ToggleSplitButton =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToggleSplitButton",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButton),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ToggleSplitButton
    };

    static PyGetSetDef getset_ToggleSplitButton_Static[] = {
        { "is_checked_property", reinterpret_cast<getter>(ToggleSplitButton_get_IsCheckedProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ToggleSplitButton_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ToggleSplitButton_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ToggleSplitButton_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ToggleSplitButton_Static) },
        { }
    };

    static PyType_Spec type_spec_ToggleSplitButton_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToggleSplitButton_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ToggleSplitButton_Static
    };

    // ----- ToggleSplitButtonIsCheckedChangedEventArgs class --------------------

    static PyObject* _new_ToggleSplitButtonIsCheckedChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButtonIsCheckedChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButtonIsCheckedChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_ToggleSplitButtonIsCheckedChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButtonIsCheckedChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_ToggleSplitButtonIsCheckedChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButtonIsCheckedChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ToggleSplitButtonIsCheckedChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ToggleSplitButtonIsCheckedChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ToggleSplitButtonIsCheckedChangedEventArgs[] = {
        { "_assign_array_", _assign_array_ToggleSplitButtonIsCheckedChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ToggleSplitButtonIsCheckedChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ToggleSplitButtonIsCheckedChangedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_ToggleSplitButtonIsCheckedChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ToggleSplitButtonIsCheckedChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ToggleSplitButtonIsCheckedChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ToggleSplitButtonIsCheckedChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ToggleSplitButtonIsCheckedChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_ToggleSplitButtonIsCheckedChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToggleSplitButtonIsCheckedChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSplitButtonIsCheckedChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ToggleSplitButtonIsCheckedChangedEventArgs
    };

    // ----- ToggleSwitch class --------------------

    static PyObject* _new_ToggleSwitch(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::Microsoft::UI::Xaml::Controls::ToggleSwitch 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_ToggleSwitch(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ToggleSwitch_get_OnContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OnContentTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OnContentTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSwitch_put_OnContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OnContentTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.OnContentTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSwitch_get_OnContent(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OnContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OnContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSwitch_put_OnContent(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OnContent"))
        {
            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.OnContent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSwitch_get_OffContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OffContentTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OffContentTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSwitch_put_OffContentTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OffContentTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.OffContentTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSwitch_get_OffContent(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OffContent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.OffContent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSwitch_put_OffContent(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OffContent"))
        {
            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.OffContent(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSwitch_get_IsOn(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"IsOn"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsOn());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSwitch_put_IsOn(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"IsOn"))
        {
            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.IsOn(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSwitch_get_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"HeaderTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HeaderTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSwitch_put_HeaderTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"HeaderTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.HeaderTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSwitch_get_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"Header"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Header());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToggleSwitch_put_Header(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"Header"))
        {
            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.Header(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToggleSwitch_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_get_HeaderProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"HeaderProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch::HeaderProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_get_HeaderTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"HeaderTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch::HeaderTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_get_IsOnProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"IsOnProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch::IsOnProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_get_OffContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OffContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch::OffContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_get_OffContentTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OffContentTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch::OffContentTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_get_OnContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OnContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch::OnContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_get_OnContentTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"OnContentTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch::OnContentTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_add_Toggled(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"Toggled"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.Toggled(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToggleSwitch_remove_Toggled(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToggleSwitch", L"Toggled"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Toggled(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ToggleSwitch(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ToggleSwitch(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ToggleSwitch>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ToggleSwitch[] = {
        { "add_toggled", reinterpret_cast<PyCFunction>(ToggleSwitch_add_Toggled), METH_O, nullptr },
        { "remove_toggled", reinterpret_cast<PyCFunction>(ToggleSwitch_remove_Toggled), METH_O, nullptr },
        { "_assign_array_", _assign_array_ToggleSwitch, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ToggleSwitch), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ToggleSwitch[] = {
        { "on_content_template", reinterpret_cast<getter>(ToggleSwitch_get_OnContentTemplate), reinterpret_cast<setter>(ToggleSwitch_put_OnContentTemplate), nullptr, nullptr },
        { "on_content", reinterpret_cast<getter>(ToggleSwitch_get_OnContent), reinterpret_cast<setter>(ToggleSwitch_put_OnContent), nullptr, nullptr },
        { "off_content_template", reinterpret_cast<getter>(ToggleSwitch_get_OffContentTemplate), reinterpret_cast<setter>(ToggleSwitch_put_OffContentTemplate), nullptr, nullptr },
        { "off_content", reinterpret_cast<getter>(ToggleSwitch_get_OffContent), reinterpret_cast<setter>(ToggleSwitch_put_OffContent), nullptr, nullptr },
        { "is_on", reinterpret_cast<getter>(ToggleSwitch_get_IsOn), reinterpret_cast<setter>(ToggleSwitch_put_IsOn), nullptr, nullptr },
        { "header_template", reinterpret_cast<getter>(ToggleSwitch_get_HeaderTemplate), reinterpret_cast<setter>(ToggleSwitch_put_HeaderTemplate), nullptr, nullptr },
        { "header", reinterpret_cast<getter>(ToggleSwitch_get_Header), reinterpret_cast<setter>(ToggleSwitch_put_Header), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(ToggleSwitch_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ToggleSwitch[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ToggleSwitch) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ToggleSwitch) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ToggleSwitch) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ToggleSwitch) },
        { },
    };

    static PyType_Spec type_spec_ToggleSwitch =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToggleSwitch",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ToggleSwitch),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ToggleSwitch
    };

    static PyGetSetDef getset_ToggleSwitch_Static[] = {
        { "header_property", reinterpret_cast<getter>(ToggleSwitch_get_HeaderProperty), nullptr, nullptr, nullptr },
        { "header_template_property", reinterpret_cast<getter>(ToggleSwitch_get_HeaderTemplateProperty), nullptr, nullptr, nullptr },
        { "is_on_property", reinterpret_cast<getter>(ToggleSwitch_get_IsOnProperty), nullptr, nullptr, nullptr },
        { "off_content_property", reinterpret_cast<getter>(ToggleSwitch_get_OffContentProperty), nullptr, nullptr, nullptr },
        { "off_content_template_property", reinterpret_cast<getter>(ToggleSwitch_get_OffContentTemplateProperty), nullptr, nullptr, nullptr },
        { "on_content_property", reinterpret_cast<getter>(ToggleSwitch_get_OnContentProperty), nullptr, nullptr, nullptr },
        { "on_content_template_property", reinterpret_cast<getter>(ToggleSwitch_get_OnContentTemplateProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ToggleSwitch_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ToggleSwitch_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ToggleSwitch_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ToggleSwitch_Static) },
        { }
    };

    static PyType_Spec type_spec_ToggleSwitch_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToggleSwitch_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ToggleSwitch_Static
    };

    // ----- ToolTip class --------------------

    static PyObject* _new_ToolTip(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::Microsoft::UI::Xaml::Controls::ToolTip 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_ToolTip(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ToolTip_get_VerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"VerticalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToolTip_put_VerticalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"VerticalOffset"))
        {
            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<double>(arg);

            self->obj.VerticalOffset(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToolTip_get_PlacementTarget(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"PlacementTarget"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlacementTarget());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToolTip_put_PlacementTarget(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"PlacementTarget"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.PlacementTarget(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToolTip_get_PlacementRect(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"PlacementRect"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PlacementRect());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToolTip_put_PlacementRect(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"PlacementRect"))
        {
            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::IReference<winrt::Windows::Foundation::Rect>>(arg);

            self->obj.PlacementRect(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToolTip_get_Placement(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"Placement"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Placement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToolTip_put_Placement(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"Placement"))
        {
            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::Microsoft::UI::Xaml::Controls::Primitives::PlacementMode>(arg);

            self->obj.Placement(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToolTip_get_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"IsOpen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsOpen());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToolTip_put_IsOpen(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"IsOpen"))
        {
            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.IsOpen(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToolTip_get_HorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"HorizontalOffset"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalOffset());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ToolTip_put_HorizontalOffset(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"HorizontalOffset"))
        {
            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<double>(arg);

            self->obj.HorizontalOffset(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ToolTip_get_TemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"TemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_get_HorizontalOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"HorizontalOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTip::HorizontalOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_get_IsOpenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"IsOpenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTip::IsOpenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_get_PlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"PlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTip::PlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_get_PlacementRectProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"PlacementRectProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTip::PlacementRectProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_get_PlacementTargetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"PlacementTargetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTip::PlacementTargetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_get_VerticalOffsetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"VerticalOffsetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTip::VerticalOffsetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_add_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.Closed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_remove_Closed(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"Closed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Closed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_add_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::RoutedEventHandler>(arg);

            return py::convert(self->obj.Opened(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTip_remove_Opened(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.ToolTip", L"Opened"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Opened(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ToolTip(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ToolTip>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ToolTip(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ToolTip>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ToolTip[] = {
        { "add_closed", reinterpret_cast<PyCFunction>(ToolTip_add_Closed), METH_O, nullptr },
        { "remove_closed", reinterpret_cast<PyCFunction>(ToolTip_remove_Closed), METH_O, nullptr },
        { "add_opened", reinterpret_cast<PyCFunction>(ToolTip_add_Opened), METH_O, nullptr },
        { "remove_opened", reinterpret_cast<PyCFunction>(ToolTip_remove_Opened), METH_O, nullptr },
        { "_assign_array_", _assign_array_ToolTip, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ToolTip), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ToolTip[] = {
        { "vertical_offset", reinterpret_cast<getter>(ToolTip_get_VerticalOffset), reinterpret_cast<setter>(ToolTip_put_VerticalOffset), nullptr, nullptr },
        { "placement_target", reinterpret_cast<getter>(ToolTip_get_PlacementTarget), reinterpret_cast<setter>(ToolTip_put_PlacementTarget), nullptr, nullptr },
        { "placement_rect", reinterpret_cast<getter>(ToolTip_get_PlacementRect), reinterpret_cast<setter>(ToolTip_put_PlacementRect), nullptr, nullptr },
        { "placement", reinterpret_cast<getter>(ToolTip_get_Placement), reinterpret_cast<setter>(ToolTip_put_Placement), nullptr, nullptr },
        { "is_open", reinterpret_cast<getter>(ToolTip_get_IsOpen), reinterpret_cast<setter>(ToolTip_put_IsOpen), nullptr, nullptr },
        { "horizontal_offset", reinterpret_cast<getter>(ToolTip_get_HorizontalOffset), reinterpret_cast<setter>(ToolTip_put_HorizontalOffset), nullptr, nullptr },
        { "template_settings", reinterpret_cast<getter>(ToolTip_get_TemplateSettings), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ToolTip[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ToolTip) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ToolTip) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ToolTip) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ToolTip) },
        { },
    };

    static PyType_Spec type_spec_ToolTip =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToolTip",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTip),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ToolTip
    };

    static PyGetSetDef getset_ToolTip_Static[] = {
        { "horizontal_offset_property", reinterpret_cast<getter>(ToolTip_get_HorizontalOffsetProperty), nullptr, nullptr, nullptr },
        { "is_open_property", reinterpret_cast<getter>(ToolTip_get_IsOpenProperty), nullptr, nullptr, nullptr },
        { "placement_property", reinterpret_cast<getter>(ToolTip_get_PlacementProperty), nullptr, nullptr, nullptr },
        { "placement_rect_property", reinterpret_cast<getter>(ToolTip_get_PlacementRectProperty), nullptr, nullptr, nullptr },
        { "placement_target_property", reinterpret_cast<getter>(ToolTip_get_PlacementTargetProperty), nullptr, nullptr, nullptr },
        { "vertical_offset_property", reinterpret_cast<getter>(ToolTip_get_VerticalOffsetProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ToolTip_Static[] = {
        { }
    };

    static PyType_Slot type_slots_ToolTip_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ToolTip_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ToolTip_Static) },
        { }
    };

    static PyType_Spec type_spec_ToolTip_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToolTip_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ToolTip_Static
    };

    // ----- ToolTipService class --------------------

    static PyObject* _new_ToolTipService(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ToolTipService>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ToolTipService>::type_name);
        return nullptr;
    }

    static void _dealloc_ToolTipService(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTipService* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ToolTipService_GetPlacement(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"GetPlacement", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTipService::GetPlacement(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ToolTipService_GetPlacementTarget(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"GetPlacementTarget", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTipService::GetPlacementTarget(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ToolTipService_GetToolTip(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"GetToolTip", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTipService::GetToolTip(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ToolTipService_SetPlacement(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"SetPlacement", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::Primitives::PlacementMode>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ToolTipService::SetPlacement(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ToolTipService_SetPlacementTarget(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"SetPlacementTarget", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ToolTipService::SetPlacementTarget(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ToolTipService_SetToolTip(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"SetToolTip", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::ToolTipService::SetToolTip(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ToolTipService_get_PlacementProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"PlacementProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTipService::PlacementProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTipService_get_PlacementTargetProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"PlacementTargetProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTipService::PlacementTargetProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ToolTipService_get_ToolTipProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ToolTipService", L"ToolTipProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::ToolTipService::ToolTipProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ToolTipService(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ToolTipService>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ToolTipService(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ToolTipService>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ToolTipService[] = {
        { "_assign_array_", _assign_array_ToolTipService, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ToolTipService), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ToolTipService[] = {
        { }
    };

    static PyType_Slot _type_slots_ToolTipService[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ToolTipService) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ToolTipService) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ToolTipService) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ToolTipService) },
        { },
    };

    static PyType_Spec type_spec_ToolTipService =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToolTipService",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ToolTipService),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ToolTipService
    };

    static PyGetSetDef getset_ToolTipService_Static[] = {
        { "placement_property", reinterpret_cast<getter>(ToolTipService_get_PlacementProperty), nullptr, nullptr, nullptr },
        { "placement_target_property", reinterpret_cast<getter>(ToolTipService_get_PlacementTargetProperty), nullptr, nullptr, nullptr },
        { "tool_tip_property", reinterpret_cast<getter>(ToolTipService_get_ToolTipProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_ToolTipService_Static[] = {
        { "get_placement", reinterpret_cast<PyCFunction>(ToolTipService_GetPlacement), METH_VARARGS, nullptr },
        { "get_placement_target", reinterpret_cast<PyCFunction>(ToolTipService_GetPlacementTarget), METH_VARARGS, nullptr },
        { "get_tool_tip", reinterpret_cast<PyCFunction>(ToolTipService_GetToolTip), METH_VARARGS, nullptr },
        { "set_placement", reinterpret_cast<PyCFunction>(ToolTipService_SetPlacement), METH_VARARGS, nullptr },
        { "set_placement_target", reinterpret_cast<PyCFunction>(ToolTipService_SetPlacementTarget), METH_VARARGS, nullptr },
        { "set_tool_tip", reinterpret_cast<PyCFunction>(ToolTipService_SetToolTip), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_ToolTipService_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_ToolTipService_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_ToolTipService_Static) },
        { }
    };

    static PyType_Spec type_spec_ToolTipService_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ToolTipService_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_ToolTipService_Static
    };

    // ----- TreeView class --------------------

    static PyObject* _new_TreeView(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::Microsoft::UI::Xaml::Controls::TreeView 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_TreeView(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeView_Collapse(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"Collapse", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::TreeViewNode>(args, 0);

                self->obj.Collapse(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TreeView_ContainerFromItem(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ContainerFromItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.ContainerFromItem(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TreeView_ContainerFromNode(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ContainerFromNode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::TreeViewNode>(args, 0);

                return py::convert(self->obj.ContainerFromNode(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TreeView_Expand(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"Expand", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::TreeViewNode>(args, 0);

                self->obj.Expand(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TreeView_ItemFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.ItemFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TreeView_NodeFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"NodeFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.NodeFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TreeView_SelectAll(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectAll", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.SelectAll();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* TreeView_get_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectionMode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectionMode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_SelectionMode(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectionMode"))
        {
            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::Microsoft::UI::Xaml::Controls::TreeViewSelectionMode>(arg);

            self->obj.SelectionMode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_RootNodes(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"RootNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RootNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_SelectedNodes(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectedNodes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedNodes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_SelectedNode(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectedNode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedNode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_SelectedNode(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectedNode"))
        {
            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::Microsoft::UI::Xaml::Controls::TreeViewNode>(arg);

            self->obj.SelectedNode(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_SelectedItem(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectedItem"))
        {
            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.SelectedItem(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_ItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemTemplateSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplateSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_ItemTemplateSelector(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemTemplateSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::DataTemplateSelector>(arg);

            self->obj.ItemTemplateSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemTemplate"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemTemplate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_ItemTemplate(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemTemplate"))
        {
            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::Microsoft::UI::Xaml::DataTemplate>(arg);

            self->obj.ItemTemplate(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_ItemContainerTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerTransitions"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerTransitions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_ItemContainerTransitions(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerTransitions"))
        {
            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::Microsoft::UI::Xaml::Media::Animation::TransitionCollection>(arg);

            self->obj.ItemContainerTransitions(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_ItemContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerStyleSelector"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerStyleSelector());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_ItemContainerStyleSelector(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerStyleSelector"))
        {
            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::Microsoft::UI::Xaml::Controls::StyleSelector>(arg);

            self->obj.ItemContainerStyleSelector(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_ItemContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerStyle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerStyle());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_ItemContainerStyle(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerStyle"))
        {
            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::Microsoft::UI::Xaml::Style>(arg);

            self->obj.ItemContainerStyle(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_CanReorderItems(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"CanReorderItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanReorderItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_CanReorderItems(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"CanReorderItems"))
        {
            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.CanReorderItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_CanDragItems(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"CanDragItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanDragItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeView_put_CanDragItems(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"CanDragItems"))
        {
            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.CanDragItems(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeView_get_SelectedItems(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SelectedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_SelectedItemProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectedItemProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::SelectedItemProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_SelectionModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectionModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::SelectionModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_CanDragItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"CanDragItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::CanDragItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_CanReorderItemsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"CanReorderItemsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::CanReorderItemsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_ItemContainerStyleProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerStyleProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::ItemContainerStyleProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_ItemContainerStyleSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerStyleSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::ItemContainerStyleSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_ItemContainerTransitionsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemContainerTransitionsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::ItemContainerTransitionsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_ItemTemplateProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemTemplateProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::ItemTemplateProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_ItemTemplateSelectorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemTemplateSelectorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::ItemTemplateSelectorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeView::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_add_Collapsed(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"Collapsed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TreeView, winrt::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs>>(arg);

            return py::convert(self->obj.Collapsed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_remove_Collapsed(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"Collapsed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Collapsed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_add_Expanding(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"Expanding"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TreeView, winrt::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs>>(arg);

            return py::convert(self->obj.Expanding(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_remove_Expanding(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"Expanding"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Expanding(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_add_ItemInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TreeView, winrt::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs>>(arg);

            return py::convert(self->obj.ItemInvoked(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_remove_ItemInvoked(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"ItemInvoked"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ItemInvoked(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_add_DragItemsCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"DragItemsCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TreeView, winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs>>(arg);

            return py::convert(self->obj.DragItemsCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_remove_DragItemsCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"DragItemsCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.DragItemsCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_add_DragItemsStarting(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"DragItemsStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TreeView, winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs>>(arg);

            return py::convert(self->obj.DragItemsStarting(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_remove_DragItemsStarting(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"DragItemsStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.DragItemsStarting(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_add_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TreeView, winrt::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs>>(arg);

            return py::convert(self->obj.SelectionChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeView_remove_SelectionChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TreeView", L"SelectionChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.SelectionChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeView[] = {
        { "collapse", reinterpret_cast<PyCFunction>(TreeView_Collapse), METH_VARARGS, nullptr },
        { "container_from_item", reinterpret_cast<PyCFunction>(TreeView_ContainerFromItem), METH_VARARGS, nullptr },
        { "container_from_node", reinterpret_cast<PyCFunction>(TreeView_ContainerFromNode), METH_VARARGS, nullptr },
        { "expand", reinterpret_cast<PyCFunction>(TreeView_Expand), METH_VARARGS, nullptr },
        { "item_from_container", reinterpret_cast<PyCFunction>(TreeView_ItemFromContainer), METH_VARARGS, nullptr },
        { "node_from_container", reinterpret_cast<PyCFunction>(TreeView_NodeFromContainer), METH_VARARGS, nullptr },
        { "select_all", reinterpret_cast<PyCFunction>(TreeView_SelectAll), METH_VARARGS, nullptr },
        { "add_collapsed", reinterpret_cast<PyCFunction>(TreeView_add_Collapsed), METH_O, nullptr },
        { "remove_collapsed", reinterpret_cast<PyCFunction>(TreeView_remove_Collapsed), METH_O, nullptr },
        { "add_expanding", reinterpret_cast<PyCFunction>(TreeView_add_Expanding), METH_O, nullptr },
        { "remove_expanding", reinterpret_cast<PyCFunction>(TreeView_remove_Expanding), METH_O, nullptr },
        { "add_item_invoked", reinterpret_cast<PyCFunction>(TreeView_add_ItemInvoked), METH_O, nullptr },
        { "remove_item_invoked", reinterpret_cast<PyCFunction>(TreeView_remove_ItemInvoked), METH_O, nullptr },
        { "add_drag_items_completed", reinterpret_cast<PyCFunction>(TreeView_add_DragItemsCompleted), METH_O, nullptr },
        { "remove_drag_items_completed", reinterpret_cast<PyCFunction>(TreeView_remove_DragItemsCompleted), METH_O, nullptr },
        { "add_drag_items_starting", reinterpret_cast<PyCFunction>(TreeView_add_DragItemsStarting), METH_O, nullptr },
        { "remove_drag_items_starting", reinterpret_cast<PyCFunction>(TreeView_remove_DragItemsStarting), METH_O, nullptr },
        { "add_selection_changed", reinterpret_cast<PyCFunction>(TreeView_add_SelectionChanged), METH_O, nullptr },
        { "remove_selection_changed", reinterpret_cast<PyCFunction>(TreeView_remove_SelectionChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_TreeView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeView[] = {
        { "selection_mode", reinterpret_cast<getter>(TreeView_get_SelectionMode), reinterpret_cast<setter>(TreeView_put_SelectionMode), nullptr, nullptr },
        { "root_nodes", reinterpret_cast<getter>(TreeView_get_RootNodes), nullptr, nullptr, nullptr },
        { "selected_nodes", reinterpret_cast<getter>(TreeView_get_SelectedNodes), nullptr, nullptr, nullptr },
        { "selected_node", reinterpret_cast<getter>(TreeView_get_SelectedNode), reinterpret_cast<setter>(TreeView_put_SelectedNode), nullptr, nullptr },
        { "selected_item", reinterpret_cast<getter>(TreeView_get_SelectedItem), reinterpret_cast<setter>(TreeView_put_SelectedItem), nullptr, nullptr },
        { "items_source", reinterpret_cast<getter>(TreeView_get_ItemsSource), reinterpret_cast<setter>(TreeView_put_ItemsSource), nullptr, nullptr },
        { "item_template_selector", reinterpret_cast<getter>(TreeView_get_ItemTemplateSelector), reinterpret_cast<setter>(TreeView_put_ItemTemplateSelector), nullptr, nullptr },
        { "item_template", reinterpret_cast<getter>(TreeView_get_ItemTemplate), reinterpret_cast<setter>(TreeView_put_ItemTemplate), nullptr, nullptr },
        { "item_container_transitions", reinterpret_cast<getter>(TreeView_get_ItemContainerTransitions), reinterpret_cast<setter>(TreeView_put_ItemContainerTransitions), nullptr, nullptr },
        { "item_container_style_selector", reinterpret_cast<getter>(TreeView_get_ItemContainerStyleSelector), reinterpret_cast<setter>(TreeView_put_ItemContainerStyleSelector), nullptr, nullptr },
        { "item_container_style", reinterpret_cast<getter>(TreeView_get_ItemContainerStyle), reinterpret_cast<setter>(TreeView_put_ItemContainerStyle), nullptr, nullptr },
        { "can_reorder_items", reinterpret_cast<getter>(TreeView_get_CanReorderItems), reinterpret_cast<setter>(TreeView_put_CanReorderItems), nullptr, nullptr },
        { "can_drag_items", reinterpret_cast<getter>(TreeView_get_CanDragItems), reinterpret_cast<setter>(TreeView_put_CanDragItems), nullptr, nullptr },
        { "selected_items", reinterpret_cast<getter>(TreeView_get_SelectedItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeView) },
        { },
    };

    static PyType_Spec type_spec_TreeView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeView
    };

    static PyGetSetDef getset_TreeView_Static[] = {
        { "selected_item_property", reinterpret_cast<getter>(TreeView_get_SelectedItemProperty), nullptr, nullptr, nullptr },
        { "selection_mode_property", reinterpret_cast<getter>(TreeView_get_SelectionModeProperty), nullptr, nullptr, nullptr },
        { "can_drag_items_property", reinterpret_cast<getter>(TreeView_get_CanDragItemsProperty), nullptr, nullptr, nullptr },
        { "can_reorder_items_property", reinterpret_cast<getter>(TreeView_get_CanReorderItemsProperty), nullptr, nullptr, nullptr },
        { "item_container_style_property", reinterpret_cast<getter>(TreeView_get_ItemContainerStyleProperty), nullptr, nullptr, nullptr },
        { "item_container_style_selector_property", reinterpret_cast<getter>(TreeView_get_ItemContainerStyleSelectorProperty), nullptr, nullptr, nullptr },
        { "item_container_transitions_property", reinterpret_cast<getter>(TreeView_get_ItemContainerTransitionsProperty), nullptr, nullptr, nullptr },
        { "item_template_property", reinterpret_cast<getter>(TreeView_get_ItemTemplateProperty), nullptr, nullptr, nullptr },
        { "item_template_selector_property", reinterpret_cast<getter>(TreeView_get_ItemTemplateSelectorProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(TreeView_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TreeView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TreeView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TreeView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TreeView_Static) },
        { }
    };

    static PyType_Spec type_spec_TreeView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TreeView_Static
    };

    // ----- TreeViewCollapsedEventArgs class --------------------

    static PyObject* _new_TreeViewCollapsedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TreeViewCollapsedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewCollapsedEventArgs_get_Node(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewCollapsedEventArgs", L"Node"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Node());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewCollapsedEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewCollapsedEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewCollapsedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewCollapsedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewCollapsedEventArgs[] = {
        { "_assign_array_", _assign_array_TreeViewCollapsedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewCollapsedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewCollapsedEventArgs[] = {
        { "node", reinterpret_cast<getter>(TreeViewCollapsedEventArgs_get_Node), nullptr, nullptr, nullptr },
        { "item", reinterpret_cast<getter>(TreeViewCollapsedEventArgs_get_Item), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewCollapsedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewCollapsedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewCollapsedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewCollapsedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewCollapsedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TreeViewCollapsedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewCollapsedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewCollapsedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewCollapsedEventArgs
    };

    // ----- TreeViewDragItemsCompletedEventArgs class --------------------

    static PyObject* _new_TreeViewDragItemsCompletedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TreeViewDragItemsCompletedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewDragItemsCompletedEventArgs_get_DropResult(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs", L"DropResult"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DropResult());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewDragItemsCompletedEventArgs_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewDragItemsCompletedEventArgs_get_NewParentItem(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs", L"NewParentItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.NewParentItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewDragItemsCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewDragItemsCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewDragItemsCompletedEventArgs[] = {
        { "_assign_array_", _assign_array_TreeViewDragItemsCompletedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewDragItemsCompletedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewDragItemsCompletedEventArgs[] = {
        { "drop_result", reinterpret_cast<getter>(TreeViewDragItemsCompletedEventArgs_get_DropResult), nullptr, nullptr, nullptr },
        { "items", reinterpret_cast<getter>(TreeViewDragItemsCompletedEventArgs_get_Items), nullptr, nullptr, nullptr },
        { "new_parent_item", reinterpret_cast<getter>(TreeViewDragItemsCompletedEventArgs_get_NewParentItem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewDragItemsCompletedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewDragItemsCompletedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewDragItemsCompletedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewDragItemsCompletedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewDragItemsCompletedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TreeViewDragItemsCompletedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewDragItemsCompletedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsCompletedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewDragItemsCompletedEventArgs
    };

    // ----- TreeViewDragItemsStartingEventArgs class --------------------

    static PyObject* _new_TreeViewDragItemsStartingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TreeViewDragItemsStartingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewDragItemsStartingEventArgs_get_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs", L"Cancel"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Cancel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewDragItemsStartingEventArgs_put_Cancel(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs", L"Cancel"))
        {
            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.Cancel(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewDragItemsStartingEventArgs_get_Data(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs", 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 PyObject* TreeViewDragItemsStartingEventArgs_get_Items(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs", L"Items"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Items());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewDragItemsStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewDragItemsStartingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewDragItemsStartingEventArgs[] = {
        { "_assign_array_", _assign_array_TreeViewDragItemsStartingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewDragItemsStartingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewDragItemsStartingEventArgs[] = {
        { "cancel", reinterpret_cast<getter>(TreeViewDragItemsStartingEventArgs_get_Cancel), reinterpret_cast<setter>(TreeViewDragItemsStartingEventArgs_put_Cancel), nullptr, nullptr },
        { "data", reinterpret_cast<getter>(TreeViewDragItemsStartingEventArgs_get_Data), nullptr, nullptr, nullptr },
        { "items", reinterpret_cast<getter>(TreeViewDragItemsStartingEventArgs_get_Items), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewDragItemsStartingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewDragItemsStartingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewDragItemsStartingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewDragItemsStartingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewDragItemsStartingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TreeViewDragItemsStartingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewDragItemsStartingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewDragItemsStartingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewDragItemsStartingEventArgs
    };

    // ----- TreeViewExpandingEventArgs class --------------------

    static PyObject* _new_TreeViewExpandingEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TreeViewExpandingEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewExpandingEventArgs_get_Node(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewExpandingEventArgs", L"Node"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Node());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewExpandingEventArgs_get_Item(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewExpandingEventArgs", L"Item"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Item());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewExpandingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewExpandingEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewExpandingEventArgs[] = {
        { "_assign_array_", _assign_array_TreeViewExpandingEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewExpandingEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewExpandingEventArgs[] = {
        { "node", reinterpret_cast<getter>(TreeViewExpandingEventArgs_get_Node), nullptr, nullptr, nullptr },
        { "item", reinterpret_cast<getter>(TreeViewExpandingEventArgs_get_Item), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewExpandingEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewExpandingEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewExpandingEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewExpandingEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewExpandingEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TreeViewExpandingEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewExpandingEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewExpandingEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewExpandingEventArgs
    };

    // ----- TreeViewItem class --------------------

    static PyObject* _new_TreeViewItem(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::Microsoft::UI::Xaml::Controls::TreeViewItem 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_TreeViewItem(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewItem_get_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"IsExpanded"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsExpanded());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"IsExpanded"))
        {
            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.IsExpanded(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_GlyphSize(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphSize"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GlyphSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_GlyphSize(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphSize"))
        {
            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<double>(arg);

            self->obj.GlyphSize(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_GlyphOpacity(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphOpacity"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GlyphOpacity());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_GlyphOpacity(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphOpacity"))
        {
            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<double>(arg);

            self->obj.GlyphOpacity(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_GlyphBrush(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphBrush"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.GlyphBrush());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_GlyphBrush(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphBrush"))
        {
            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::Microsoft::UI::Xaml::Media::Brush>(arg);

            self->obj.GlyphBrush(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_ExpandedGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"ExpandedGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExpandedGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_ExpandedGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"ExpandedGlyph"))
        {
            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.ExpandedGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_CollapsedGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"CollapsedGlyph"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CollapsedGlyph());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_CollapsedGlyph(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"CollapsedGlyph"))
        {
            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.CollapsedGlyph(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_TreeViewItemTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"TreeViewItemTemplateSettings"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TreeViewItemTemplateSettings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"ItemsSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsSource());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_ItemsSource(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"ItemsSource"))
        {
            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.ItemsSource(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_HasUnrealizedChildren(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"HasUnrealizedChildren"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasUnrealizedChildren());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItem_put_HasUnrealizedChildren(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"HasUnrealizedChildren"))
        {
            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.HasUnrealizedChildren(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItem_get_CollapsedGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"CollapsedGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::CollapsedGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_ExpandedGlyphProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"ExpandedGlyphProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::ExpandedGlyphProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_GlyphBrushProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphBrushProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::GlyphBrushProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_GlyphOpacityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphOpacityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::GlyphOpacityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_GlyphSizeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"GlyphSizeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::GlyphSizeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_IsExpandedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"IsExpandedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::IsExpandedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_TreeViewItemTemplateSettingsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"TreeViewItemTemplateSettingsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::TreeViewItemTemplateSettingsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_HasUnrealizedChildrenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"HasUnrealizedChildrenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::HasUnrealizedChildrenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItem_get_ItemsSourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItem", L"ItemsSourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItem::ItemsSourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewItem>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewItem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewItem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewItem[] = {
        { "_assign_array_", _assign_array_TreeViewItem, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewItem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewItem[] = {
        { "is_expanded", reinterpret_cast<getter>(TreeViewItem_get_IsExpanded), reinterpret_cast<setter>(TreeViewItem_put_IsExpanded), nullptr, nullptr },
        { "glyph_size", reinterpret_cast<getter>(TreeViewItem_get_GlyphSize), reinterpret_cast<setter>(TreeViewItem_put_GlyphSize), nullptr, nullptr },
        { "glyph_opacity", reinterpret_cast<getter>(TreeViewItem_get_GlyphOpacity), reinterpret_cast<setter>(TreeViewItem_put_GlyphOpacity), nullptr, nullptr },
        { "glyph_brush", reinterpret_cast<getter>(TreeViewItem_get_GlyphBrush), reinterpret_cast<setter>(TreeViewItem_put_GlyphBrush), nullptr, nullptr },
        { "expanded_glyph", reinterpret_cast<getter>(TreeViewItem_get_ExpandedGlyph), reinterpret_cast<setter>(TreeViewItem_put_ExpandedGlyph), nullptr, nullptr },
        { "collapsed_glyph", reinterpret_cast<getter>(TreeViewItem_get_CollapsedGlyph), reinterpret_cast<setter>(TreeViewItem_put_CollapsedGlyph), nullptr, nullptr },
        { "tree_view_item_template_settings", reinterpret_cast<getter>(TreeViewItem_get_TreeViewItemTemplateSettings), nullptr, nullptr, nullptr },
        { "items_source", reinterpret_cast<getter>(TreeViewItem_get_ItemsSource), reinterpret_cast<setter>(TreeViewItem_put_ItemsSource), nullptr, nullptr },
        { "has_unrealized_children", reinterpret_cast<getter>(TreeViewItem_get_HasUnrealizedChildren), reinterpret_cast<setter>(TreeViewItem_put_HasUnrealizedChildren), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewItem[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewItem) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewItem) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewItem) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewItem) },
        { },
    };

    static PyType_Spec type_spec_TreeViewItem =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewItem",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewItem
    };

    static PyGetSetDef getset_TreeViewItem_Static[] = {
        { "collapsed_glyph_property", reinterpret_cast<getter>(TreeViewItem_get_CollapsedGlyphProperty), nullptr, nullptr, nullptr },
        { "expanded_glyph_property", reinterpret_cast<getter>(TreeViewItem_get_ExpandedGlyphProperty), nullptr, nullptr, nullptr },
        { "glyph_brush_property", reinterpret_cast<getter>(TreeViewItem_get_GlyphBrushProperty), nullptr, nullptr, nullptr },
        { "glyph_opacity_property", reinterpret_cast<getter>(TreeViewItem_get_GlyphOpacityProperty), nullptr, nullptr, nullptr },
        { "glyph_size_property", reinterpret_cast<getter>(TreeViewItem_get_GlyphSizeProperty), nullptr, nullptr, nullptr },
        { "is_expanded_property", reinterpret_cast<getter>(TreeViewItem_get_IsExpandedProperty), nullptr, nullptr, nullptr },
        { "tree_view_item_template_settings_property", reinterpret_cast<getter>(TreeViewItem_get_TreeViewItemTemplateSettingsProperty), nullptr, nullptr, nullptr },
        { "has_unrealized_children_property", reinterpret_cast<getter>(TreeViewItem_get_HasUnrealizedChildrenProperty), nullptr, nullptr, nullptr },
        { "items_source_property", reinterpret_cast<getter>(TreeViewItem_get_ItemsSourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TreeViewItem_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TreeViewItem_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TreeViewItem_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TreeViewItem_Static) },
        { }
    };

    static PyType_Spec type_spec_TreeViewItem_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewItem_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TreeViewItem_Static
    };

    // ----- TreeViewItemInvokedEventArgs class --------------------

    static PyObject* _new_TreeViewItemInvokedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TreeViewItemInvokedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewItemInvokedEventArgs_get_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemInvokedEventArgs", L"Handled"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Handled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewItemInvokedEventArgs_put_Handled(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemInvokedEventArgs", L"Handled"))
        {
            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.Handled(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewItemInvokedEventArgs_get_InvokedItem(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemInvokedEventArgs", L"InvokedItem"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.InvokedItem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewItemInvokedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewItemInvokedEventArgs[] = {
        { "_assign_array_", _assign_array_TreeViewItemInvokedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewItemInvokedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewItemInvokedEventArgs[] = {
        { "handled", reinterpret_cast<getter>(TreeViewItemInvokedEventArgs_get_Handled), reinterpret_cast<setter>(TreeViewItemInvokedEventArgs_put_Handled), nullptr, nullptr },
        { "invoked_item", reinterpret_cast<getter>(TreeViewItemInvokedEventArgs_get_InvokedItem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewItemInvokedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewItemInvokedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewItemInvokedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewItemInvokedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewItemInvokedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TreeViewItemInvokedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewItemInvokedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemInvokedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewItemInvokedEventArgs
    };

    // ----- TreeViewItemTemplateSettings class --------------------

    static PyObject* _new_TreeViewItemTemplateSettings(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::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings 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_TreeViewItemTemplateSettings(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewItemTemplateSettings_get_CollapsedGlyphVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"CollapsedGlyphVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CollapsedGlyphVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItemTemplateSettings_get_DragItemsCount(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"DragItemsCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DragItemsCount());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItemTemplateSettings_get_ExpandedGlyphVisibility(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"ExpandedGlyphVisibility"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ExpandedGlyphVisibility());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItemTemplateSettings_get_Indentation(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"Indentation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Indentation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItemTemplateSettings_get_CollapsedGlyphVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"CollapsedGlyphVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings::CollapsedGlyphVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItemTemplateSettings_get_DragItemsCountProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"DragItemsCountProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings::DragItemsCountProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItemTemplateSettings_get_ExpandedGlyphVisibilityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"ExpandedGlyphVisibilityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings::ExpandedGlyphVisibilityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewItemTemplateSettings_get_IndentationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings", L"IndentationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings::IndentationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewItemTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewItemTemplateSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewItemTemplateSettings[] = {
        { "_assign_array_", _assign_array_TreeViewItemTemplateSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewItemTemplateSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewItemTemplateSettings[] = {
        { "collapsed_glyph_visibility", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_CollapsedGlyphVisibility), nullptr, nullptr, nullptr },
        { "drag_items_count", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_DragItemsCount), nullptr, nullptr, nullptr },
        { "expanded_glyph_visibility", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_ExpandedGlyphVisibility), nullptr, nullptr, nullptr },
        { "indentation", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_Indentation), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewItemTemplateSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewItemTemplateSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewItemTemplateSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewItemTemplateSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewItemTemplateSettings) },
        { },
    };

    static PyType_Spec type_spec_TreeViewItemTemplateSettings =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewItemTemplateSettings",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewItemTemplateSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewItemTemplateSettings
    };

    static PyGetSetDef getset_TreeViewItemTemplateSettings_Static[] = {
        { "collapsed_glyph_visibility_property", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_CollapsedGlyphVisibilityProperty), nullptr, nullptr, nullptr },
        { "drag_items_count_property", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_DragItemsCountProperty), nullptr, nullptr, nullptr },
        { "expanded_glyph_visibility_property", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_ExpandedGlyphVisibilityProperty), nullptr, nullptr, nullptr },
        { "indentation_property", reinterpret_cast<getter>(TreeViewItemTemplateSettings_get_IndentationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TreeViewItemTemplateSettings_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TreeViewItemTemplateSettings_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TreeViewItemTemplateSettings_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TreeViewItemTemplateSettings_Static) },
        { }
    };

    static PyType_Spec type_spec_TreeViewItemTemplateSettings_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewItemTemplateSettings_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TreeViewItemTemplateSettings_Static
    };

    // ----- TreeViewList class --------------------

    static PyObject* _new_TreeViewList(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::Microsoft::UI::Xaml::Controls::TreeViewList 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_TreeViewList(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewList* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_TreeViewList(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewList>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewList(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewList>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewList[] = {
        { "_assign_array_", _assign_array_TreeViewList, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewList), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewList[] = {
        { }
    };

    static PyType_Slot _type_slots_TreeViewList[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewList) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewList) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewList) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewList) },
        { },
    };

    static PyType_Spec type_spec_TreeViewList =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewList",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewList),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewList
    };

    // ----- TreeViewNode class --------------------

    static PyObject* _new_TreeViewNode(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::Microsoft::UI::Xaml::Controls::TreeViewNode 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_TreeViewNode(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewNode_get_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"IsExpanded"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsExpanded());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewNode_put_IsExpanded(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"IsExpanded"))
        {
            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.IsExpanded(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewNode_get_HasUnrealizedChildren(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"HasUnrealizedChildren"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasUnrealizedChildren());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewNode_put_HasUnrealizedChildren(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"HasUnrealizedChildren"))
        {
            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.HasUnrealizedChildren(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewNode_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TreeViewNode_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"Content"))
        {
            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.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TreeViewNode_get_Children(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"Children"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Children());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewNode_get_Depth(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"Depth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Depth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewNode_get_HasChildren(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"HasChildren"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HasChildren());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewNode_get_Parent(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"Parent"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Parent());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewNode_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewNode::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewNode_get_DepthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"DepthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewNode::DepthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewNode_get_HasChildrenProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"HasChildrenProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewNode::HasChildrenProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewNode_get_IsExpandedProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewNode", L"IsExpandedProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TreeViewNode::IsExpandedProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewNode(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewNode>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewNode(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewNode>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewNode[] = {
        { "_assign_array_", _assign_array_TreeViewNode, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewNode), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewNode[] = {
        { "is_expanded", reinterpret_cast<getter>(TreeViewNode_get_IsExpanded), reinterpret_cast<setter>(TreeViewNode_put_IsExpanded), nullptr, nullptr },
        { "has_unrealized_children", reinterpret_cast<getter>(TreeViewNode_get_HasUnrealizedChildren), reinterpret_cast<setter>(TreeViewNode_put_HasUnrealizedChildren), nullptr, nullptr },
        { "content", reinterpret_cast<getter>(TreeViewNode_get_Content), reinterpret_cast<setter>(TreeViewNode_put_Content), nullptr, nullptr },
        { "children", reinterpret_cast<getter>(TreeViewNode_get_Children), nullptr, nullptr, nullptr },
        { "depth", reinterpret_cast<getter>(TreeViewNode_get_Depth), nullptr, nullptr, nullptr },
        { "has_children", reinterpret_cast<getter>(TreeViewNode_get_HasChildren), nullptr, nullptr, nullptr },
        { "parent", reinterpret_cast<getter>(TreeViewNode_get_Parent), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewNode[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewNode) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewNode) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewNode) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewNode) },
        { },
    };

    static PyType_Spec type_spec_TreeViewNode =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewNode",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewNode),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewNode
    };

    static PyGetSetDef getset_TreeViewNode_Static[] = {
        { "content_property", reinterpret_cast<getter>(TreeViewNode_get_ContentProperty), nullptr, nullptr, nullptr },
        { "depth_property", reinterpret_cast<getter>(TreeViewNode_get_DepthProperty), nullptr, nullptr, nullptr },
        { "has_children_property", reinterpret_cast<getter>(TreeViewNode_get_HasChildrenProperty), nullptr, nullptr, nullptr },
        { "is_expanded_property", reinterpret_cast<getter>(TreeViewNode_get_IsExpandedProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TreeViewNode_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TreeViewNode_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TreeViewNode_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TreeViewNode_Static) },
        { }
    };

    static PyType_Spec type_spec_TreeViewNode_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewNode_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TreeViewNode_Static
    };

    // ----- TreeViewSelectionChangedEventArgs class --------------------

    static PyObject* _new_TreeViewSelectionChangedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_TreeViewSelectionChangedEventArgs(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TreeViewSelectionChangedEventArgs_get_AddedItems(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewSelectionChangedEventArgs", L"AddedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AddedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TreeViewSelectionChangedEventArgs_get_RemovedItems(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TreeViewSelectionChangedEventArgs", L"RemovedItems"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RemovedItems());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TreeViewSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TreeViewSelectionChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TreeViewSelectionChangedEventArgs[] = {
        { "_assign_array_", _assign_array_TreeViewSelectionChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TreeViewSelectionChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TreeViewSelectionChangedEventArgs[] = {
        { "added_items", reinterpret_cast<getter>(TreeViewSelectionChangedEventArgs_get_AddedItems), nullptr, nullptr, nullptr },
        { "removed_items", reinterpret_cast<getter>(TreeViewSelectionChangedEventArgs_get_RemovedItems), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TreeViewSelectionChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TreeViewSelectionChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TreeViewSelectionChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TreeViewSelectionChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TreeViewSelectionChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_TreeViewSelectionChangedEventArgs =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TreeViewSelectionChangedEventArgs",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TreeViewSelectionChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TreeViewSelectionChangedEventArgs
    };

    // ----- TwoPaneView class --------------------

    static PyObject* _new_TwoPaneView(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::Microsoft::UI::Xaml::Controls::TwoPaneView 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_TwoPaneView(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* TwoPaneView_get_WideModeConfiguration(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"WideModeConfiguration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.WideModeConfiguration());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_WideModeConfiguration(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"WideModeConfiguration"))
        {
            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::Microsoft::UI::Xaml::Controls::TwoPaneViewWideModeConfiguration>(arg);

            self->obj.WideModeConfiguration(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_TallModeConfiguration(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"TallModeConfiguration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.TallModeConfiguration());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_TallModeConfiguration(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"TallModeConfiguration"))
        {
            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::Microsoft::UI::Xaml::Controls::TwoPaneViewTallModeConfiguration>(arg);

            self->obj.TallModeConfiguration(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_PanePriority(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"PanePriority"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.PanePriority());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_PanePriority(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"PanePriority"))
        {
            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::Microsoft::UI::Xaml::Controls::TwoPaneViewPriority>(arg);

            self->obj.PanePriority(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_Pane2Length(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane2Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Pane2Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_Pane2Length(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane2Length"))
        {
            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::Microsoft::UI::Xaml::GridLength>(arg);

            self->obj.Pane2Length(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_Pane2(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane2"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Pane2());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_Pane2(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane2"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Pane2(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_Pane1Length(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane1Length"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Pane1Length());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_Pane1Length(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane1Length"))
        {
            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::Microsoft::UI::Xaml::GridLength>(arg);

            self->obj.Pane1Length(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_Pane1(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane1"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Pane1());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_Pane1(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane1"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Pane1(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_MinWideModeWidth(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"MinWideModeWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinWideModeWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_MinWideModeWidth(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"MinWideModeWidth"))
        {
            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<double>(arg);

            self->obj.MinWideModeWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_MinTallModeHeight(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"MinTallModeHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinTallModeHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int TwoPaneView_put_MinTallModeHeight(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"MinTallModeHeight"))
        {
            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<double>(arg);

            self->obj.MinTallModeHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* TwoPaneView_get_Mode(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Mode"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Mode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_MinTallModeHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"MinTallModeHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::MinTallModeHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_MinWideModeWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"MinWideModeWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::MinWideModeWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_ModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"ModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::ModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_Pane1LengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane1LengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::Pane1LengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_Pane1Property(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane1Property"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::Pane1Property());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_Pane2LengthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane2LengthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::Pane2LengthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_Pane2Property(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"Pane2Property"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::Pane2Property());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_PanePriorityProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"PanePriorityProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::PanePriorityProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_TallModeConfigurationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"TallModeConfigurationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::TallModeConfigurationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_get_WideModeConfigurationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"WideModeConfigurationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::TwoPaneView::WideModeConfigurationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_add_ModeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"ModeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::TwoPaneView, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.ModeChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* TwoPaneView_remove_ModeChanged(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.TwoPaneView", L"ModeChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ModeChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_TwoPaneView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::TwoPaneView>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_TwoPaneView(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::TwoPaneView>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_TwoPaneView[] = {
        { "add_mode_changed", reinterpret_cast<PyCFunction>(TwoPaneView_add_ModeChanged), METH_O, nullptr },
        { "remove_mode_changed", reinterpret_cast<PyCFunction>(TwoPaneView_remove_ModeChanged), METH_O, nullptr },
        { "_assign_array_", _assign_array_TwoPaneView, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_TwoPaneView), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_TwoPaneView[] = {
        { "wide_mode_configuration", reinterpret_cast<getter>(TwoPaneView_get_WideModeConfiguration), reinterpret_cast<setter>(TwoPaneView_put_WideModeConfiguration), nullptr, nullptr },
        { "tall_mode_configuration", reinterpret_cast<getter>(TwoPaneView_get_TallModeConfiguration), reinterpret_cast<setter>(TwoPaneView_put_TallModeConfiguration), nullptr, nullptr },
        { "pane_priority", reinterpret_cast<getter>(TwoPaneView_get_PanePriority), reinterpret_cast<setter>(TwoPaneView_put_PanePriority), nullptr, nullptr },
        { "pane2_length", reinterpret_cast<getter>(TwoPaneView_get_Pane2Length), reinterpret_cast<setter>(TwoPaneView_put_Pane2Length), nullptr, nullptr },
        { "pane2", reinterpret_cast<getter>(TwoPaneView_get_Pane2), reinterpret_cast<setter>(TwoPaneView_put_Pane2), nullptr, nullptr },
        { "pane1_length", reinterpret_cast<getter>(TwoPaneView_get_Pane1Length), reinterpret_cast<setter>(TwoPaneView_put_Pane1Length), nullptr, nullptr },
        { "pane1", reinterpret_cast<getter>(TwoPaneView_get_Pane1), reinterpret_cast<setter>(TwoPaneView_put_Pane1), nullptr, nullptr },
        { "min_wide_mode_width", reinterpret_cast<getter>(TwoPaneView_get_MinWideModeWidth), reinterpret_cast<setter>(TwoPaneView_put_MinWideModeWidth), nullptr, nullptr },
        { "min_tall_mode_height", reinterpret_cast<getter>(TwoPaneView_get_MinTallModeHeight), reinterpret_cast<setter>(TwoPaneView_put_MinTallModeHeight), nullptr, nullptr },
        { "mode", reinterpret_cast<getter>(TwoPaneView_get_Mode), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_TwoPaneView[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_TwoPaneView) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_TwoPaneView) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_TwoPaneView) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_TwoPaneView) },
        { },
    };

    static PyType_Spec type_spec_TwoPaneView =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TwoPaneView",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::TwoPaneView),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_TwoPaneView
    };

    static PyGetSetDef getset_TwoPaneView_Static[] = {
        { "min_tall_mode_height_property", reinterpret_cast<getter>(TwoPaneView_get_MinTallModeHeightProperty), nullptr, nullptr, nullptr },
        { "min_wide_mode_width_property", reinterpret_cast<getter>(TwoPaneView_get_MinWideModeWidthProperty), nullptr, nullptr, nullptr },
        { "mode_property", reinterpret_cast<getter>(TwoPaneView_get_ModeProperty), nullptr, nullptr, nullptr },
        { "pane1_length_property", reinterpret_cast<getter>(TwoPaneView_get_Pane1LengthProperty), nullptr, nullptr, nullptr },
        { "pane1_property", reinterpret_cast<getter>(TwoPaneView_get_Pane1Property), nullptr, nullptr, nullptr },
        { "pane2_length_property", reinterpret_cast<getter>(TwoPaneView_get_Pane2LengthProperty), nullptr, nullptr, nullptr },
        { "pane2_property", reinterpret_cast<getter>(TwoPaneView_get_Pane2Property), nullptr, nullptr, nullptr },
        { "pane_priority_property", reinterpret_cast<getter>(TwoPaneView_get_PanePriorityProperty), nullptr, nullptr, nullptr },
        { "tall_mode_configuration_property", reinterpret_cast<getter>(TwoPaneView_get_TallModeConfigurationProperty), nullptr, nullptr, nullptr },
        { "wide_mode_configuration_property", reinterpret_cast<getter>(TwoPaneView_get_WideModeConfigurationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_TwoPaneView_Static[] = {
        { }
    };

    static PyType_Slot type_slots_TwoPaneView_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_TwoPaneView_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_TwoPaneView_Static) },
        { }
    };

    static PyType_Spec type_spec_TwoPaneView_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.TwoPaneView_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_TwoPaneView_Static
    };

    // ----- UIElementCollection class --------------------

    static PyObject* _new_UIElementCollection(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::UIElementCollection>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::UIElementCollection>::type_name);
        return nullptr;
    }

    static void _dealloc_UIElementCollection(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* UIElementCollection_Append(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"Append", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.Append(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_Clear(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"Clear", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Clear();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_First(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", 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* UIElementCollection_GetAt(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", 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* UIElementCollection_GetMany(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", 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::Microsoft::UI::Xaml::UIElement, 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* UIElementCollection_GetView(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"GetView", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.GetView());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_IndexOf(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"IndexOf", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(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* UIElementCollection_InsertAt(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"InsertAt", 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::Microsoft::UI::Xaml::UIElement>(args, 1);

                self->obj.InsertAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_Move(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"Move", 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.Move(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_RemoveAt(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"RemoveAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<uint32_t>(args, 0);

                self->obj.RemoveAt(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_RemoveAtEnd(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"RemoveAtEnd", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.RemoveAtEnd();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_ReplaceAll(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"ReplaceAll", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<py::pybuf_view<winrt::Microsoft::UI::Xaml::UIElement, false>>(args, 0);

                self->obj.ReplaceAll(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_SetAt(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", L"SetAt", 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::Microsoft::UI::Xaml::UIElement>(args, 1);

                self->obj.SetAt(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* UIElementCollection_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UIElementCollection", 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_UIElementCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::UIElementCollection>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_UIElementCollection(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::UIElementCollection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _iterator_UIElementCollection(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self) noexcept
    {
        try
        {
            return py::convert(self->obj.First());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static Py_ssize_t _seq_length_UIElementCollection(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self) noexcept
    {
        try
        {
            return static_cast<Py_ssize_t>(self->obj.Size());
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _seq_item_UIElementCollection(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* 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_UIElementCollection(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* 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_UIElementCollection(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::Microsoft::UI::Xaml::UIElement> items(static_cast<uint32_t>(length), empty_instance<winrt::Microsoft::UI::Xaml::UIElement>::get());

            auto count = self->obj.GetMany(static_cast<uint32_t>(start), items);

            if (count != static_cast<uint32_t>(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 int _seq_assign_UIElementCollection(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection* self, Py_ssize_t i, PyObject* value) noexcept
    {
        try
        {
            if (value == nullptr) { self->obj.RemoveAt(static_cast<uint32_t>(i)); }
            else { self->obj.SetAt(static_cast<uint32_t>(i), py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(value)); }
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyMethodDef _methods_UIElementCollection[] = {
        { "append", reinterpret_cast<PyCFunction>(UIElementCollection_Append), METH_VARARGS, nullptr },
        { "clear", reinterpret_cast<PyCFunction>(UIElementCollection_Clear), METH_VARARGS, nullptr },
        { "first", reinterpret_cast<PyCFunction>(UIElementCollection_First), METH_VARARGS, nullptr },
        { "get_at", reinterpret_cast<PyCFunction>(UIElementCollection_GetAt), METH_VARARGS, nullptr },
        { "get_many", reinterpret_cast<PyCFunction>(UIElementCollection_GetMany), METH_VARARGS, nullptr },
        { "get_view", reinterpret_cast<PyCFunction>(UIElementCollection_GetView), METH_VARARGS, nullptr },
        { "index_of", reinterpret_cast<PyCFunction>(UIElementCollection_IndexOf), METH_VARARGS, nullptr },
        { "insert_at", reinterpret_cast<PyCFunction>(UIElementCollection_InsertAt), METH_VARARGS, nullptr },
        { "move", reinterpret_cast<PyCFunction>(UIElementCollection_Move), METH_VARARGS, nullptr },
        { "remove_at", reinterpret_cast<PyCFunction>(UIElementCollection_RemoveAt), METH_VARARGS, nullptr },
        { "remove_at_end", reinterpret_cast<PyCFunction>(UIElementCollection_RemoveAtEnd), METH_VARARGS, nullptr },
        { "replace_all", reinterpret_cast<PyCFunction>(UIElementCollection_ReplaceAll), METH_VARARGS, nullptr },
        { "set_at", reinterpret_cast<PyCFunction>(UIElementCollection_SetAt), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_UIElementCollection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_UIElementCollection), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_UIElementCollection[] = {
        { "size", reinterpret_cast<getter>(UIElementCollection_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_UIElementCollection[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_UIElementCollection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_UIElementCollection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_UIElementCollection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_UIElementCollection) },
        { Py_tp_iter, reinterpret_cast<void*>(_iterator_UIElementCollection) },
        { Py_sq_length, reinterpret_cast<void*>(_seq_length_UIElementCollection) },
        { Py_sq_item, reinterpret_cast<void*>(_seq_item_UIElementCollection) },
        { Py_mp_subscript, reinterpret_cast<void*>(_seq_subscript_UIElementCollection) },
        { Py_sq_ass_item, reinterpret_cast<void*>(_seq_assign_UIElementCollection) },
        { },
    };

    static PyType_Spec type_spec_UIElementCollection =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.UIElementCollection",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::UIElementCollection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_UIElementCollection
    };

    // ----- UniformGridLayout class --------------------

    static PyObject* _new_UniformGridLayout(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::Microsoft::UI::Xaml::Controls::UniformGridLayout 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_UniformGridLayout(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* UniformGridLayout_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_MinRowSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinRowSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinRowSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_MinRowSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinRowSpacing"))
        {
            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<double>(arg);

            self->obj.MinRowSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_MinItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinItemWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinItemWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_MinItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinItemWidth"))
        {
            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<double>(arg);

            self->obj.MinItemWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_MinItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinItemHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinItemHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_MinItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinItemHeight"))
        {
            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<double>(arg);

            self->obj.MinItemHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_MinColumnSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinColumnSpacing"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MinColumnSpacing());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_MinColumnSpacing(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinColumnSpacing"))
        {
            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<double>(arg);

            self->obj.MinColumnSpacing(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MaximumRowsOrColumns"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaximumRowsOrColumns());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MaximumRowsOrColumns"))
        {
            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<int32_t>(arg);

            self->obj.MaximumRowsOrColumns(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_ItemsStretch(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"ItemsStretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsStretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_ItemsStretch(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"ItemsStretch"))
        {
            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::Microsoft::UI::Xaml::Controls::UniformGridLayoutItemsStretch>(arg);

            self->obj.ItemsStretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_ItemsJustification(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"ItemsJustification"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemsJustification());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UniformGridLayout_put_ItemsJustification(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"ItemsJustification"))
        {
            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::Microsoft::UI::Xaml::Controls::UniformGridLayoutItemsJustification>(arg);

            self->obj.ItemsJustification(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UniformGridLayout_get_ItemsJustificationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"ItemsJustificationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::ItemsJustificationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UniformGridLayout_get_ItemsStretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"ItemsStretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::ItemsStretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UniformGridLayout_get_MaximumRowsOrColumnsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MaximumRowsOrColumnsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::MaximumRowsOrColumnsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UniformGridLayout_get_MinColumnSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinColumnSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::MinColumnSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UniformGridLayout_get_MinItemHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinItemHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::MinItemHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UniformGridLayout_get_MinItemWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinItemWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::MinItemWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UniformGridLayout_get_MinRowSpacingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"MinRowSpacingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::MinRowSpacingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UniformGridLayout_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UniformGridLayout", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_UniformGridLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_UniformGridLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::UniformGridLayout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_UniformGridLayout[] = {
        { "_assign_array_", _assign_array_UniformGridLayout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_UniformGridLayout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_UniformGridLayout[] = {
        { "orientation", reinterpret_cast<getter>(UniformGridLayout_get_Orientation), reinterpret_cast<setter>(UniformGridLayout_put_Orientation), nullptr, nullptr },
        { "min_row_spacing", reinterpret_cast<getter>(UniformGridLayout_get_MinRowSpacing), reinterpret_cast<setter>(UniformGridLayout_put_MinRowSpacing), nullptr, nullptr },
        { "min_item_width", reinterpret_cast<getter>(UniformGridLayout_get_MinItemWidth), reinterpret_cast<setter>(UniformGridLayout_put_MinItemWidth), nullptr, nullptr },
        { "min_item_height", reinterpret_cast<getter>(UniformGridLayout_get_MinItemHeight), reinterpret_cast<setter>(UniformGridLayout_put_MinItemHeight), nullptr, nullptr },
        { "min_column_spacing", reinterpret_cast<getter>(UniformGridLayout_get_MinColumnSpacing), reinterpret_cast<setter>(UniformGridLayout_put_MinColumnSpacing), nullptr, nullptr },
        { "maximum_rows_or_columns", reinterpret_cast<getter>(UniformGridLayout_get_MaximumRowsOrColumns), reinterpret_cast<setter>(UniformGridLayout_put_MaximumRowsOrColumns), nullptr, nullptr },
        { "items_stretch", reinterpret_cast<getter>(UniformGridLayout_get_ItemsStretch), reinterpret_cast<setter>(UniformGridLayout_put_ItemsStretch), nullptr, nullptr },
        { "items_justification", reinterpret_cast<getter>(UniformGridLayout_get_ItemsJustification), reinterpret_cast<setter>(UniformGridLayout_put_ItemsJustification), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_UniformGridLayout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_UniformGridLayout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_UniformGridLayout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_UniformGridLayout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_UniformGridLayout) },
        { },
    };

    static PyType_Spec type_spec_UniformGridLayout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.UniformGridLayout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::UniformGridLayout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_UniformGridLayout
    };

    static PyGetSetDef getset_UniformGridLayout_Static[] = {
        { "items_justification_property", reinterpret_cast<getter>(UniformGridLayout_get_ItemsJustificationProperty), nullptr, nullptr, nullptr },
        { "items_stretch_property", reinterpret_cast<getter>(UniformGridLayout_get_ItemsStretchProperty), nullptr, nullptr, nullptr },
        { "maximum_rows_or_columns_property", reinterpret_cast<getter>(UniformGridLayout_get_MaximumRowsOrColumnsProperty), nullptr, nullptr, nullptr },
        { "min_column_spacing_property", reinterpret_cast<getter>(UniformGridLayout_get_MinColumnSpacingProperty), nullptr, nullptr, nullptr },
        { "min_item_height_property", reinterpret_cast<getter>(UniformGridLayout_get_MinItemHeightProperty), nullptr, nullptr, nullptr },
        { "min_item_width_property", reinterpret_cast<getter>(UniformGridLayout_get_MinItemWidthProperty), nullptr, nullptr, nullptr },
        { "min_row_spacing_property", reinterpret_cast<getter>(UniformGridLayout_get_MinRowSpacingProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(UniformGridLayout_get_OrientationProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_UniformGridLayout_Static[] = {
        { }
    };

    static PyType_Slot type_slots_UniformGridLayout_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_UniformGridLayout_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_UniformGridLayout_Static) },
        { }
    };

    static PyType_Spec type_spec_UniformGridLayout_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.UniformGridLayout_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_UniformGridLayout_Static
    };

    // ----- UserControl class --------------------

    static PyObject* _new_UserControl(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::Microsoft::UI::Xaml::Controls::UserControl 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_UserControl(py::wrapper::Microsoft::UI::Xaml::Controls::UserControl* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* UserControl_get_Content(py::wrapper::Microsoft::UI::Xaml::Controls::UserControl* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UserControl", L"Content"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Content());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int UserControl_put_Content(py::wrapper::Microsoft::UI::Xaml::Controls::UserControl* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UserControl", L"Content"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Content(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* UserControl_get_ContentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.UserControl", L"ContentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::UserControl::ContentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_UserControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::UserControl>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_UserControl(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::UserControl>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_UserControl[] = {
        { "_assign_array_", _assign_array_UserControl, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_UserControl), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_UserControl[] = {
        { "content", reinterpret_cast<getter>(UserControl_get_Content), reinterpret_cast<setter>(UserControl_put_Content), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_UserControl[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_UserControl) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_UserControl) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_UserControl) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_UserControl) },
        { },
    };

    static PyType_Spec type_spec_UserControl =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.UserControl",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::UserControl),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_UserControl
    };

    static PyGetSetDef getset_UserControl_Static[] = {
        { "content_property", reinterpret_cast<getter>(UserControl_get_ContentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_UserControl_Static[] = {
        { }
    };

    static PyType_Slot type_slots_UserControl_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_UserControl_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_UserControl_Static) },
        { }
    };

    static PyType_Spec type_spec_UserControl_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.UserControl_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_UserControl_Static
    };

    // ----- VariableSizedWrapGrid class --------------------

    static PyObject* _new_VariableSizedWrapGrid(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::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid 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_VariableSizedWrapGrid(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* VariableSizedWrapGrid_GetColumnSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"GetColumnSpan", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::GetColumnSpan(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_GetRowSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"GetRowSpan", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::GetRowSpan(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_SetColumnSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"SetColumnSpan", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::SetColumnSpan(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_SetRowSpan(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"SetRowSpan", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::SetRowSpan(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_VerticalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"VerticalChildrenAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalChildrenAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VariableSizedWrapGrid_put_VerticalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"VerticalChildrenAlignment"))
        {
            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::Microsoft::UI::Xaml::VerticalAlignment>(arg);

            self->obj.VerticalChildrenAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VariableSizedWrapGrid_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"MaximumRowsOrColumns"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaximumRowsOrColumns());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VariableSizedWrapGrid_put_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"MaximumRowsOrColumns"))
        {
            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<int32_t>(arg);

            self->obj.MaximumRowsOrColumns(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_ItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"ItemWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VariableSizedWrapGrid_put_ItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"ItemWidth"))
        {
            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<double>(arg);

            self->obj.ItemWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_ItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"ItemHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VariableSizedWrapGrid_put_ItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"ItemHeight"))
        {
            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<double>(arg);

            self->obj.ItemHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_HorizontalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"HorizontalChildrenAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalChildrenAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VariableSizedWrapGrid_put_HorizontalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"HorizontalChildrenAlignment"))
        {
            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::Microsoft::UI::Xaml::HorizontalAlignment>(arg);

            self->obj.HorizontalChildrenAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_ColumnSpanProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"ColumnSpanProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::ColumnSpanProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_HorizontalChildrenAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"HorizontalChildrenAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::HorizontalChildrenAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_ItemHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"ItemHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::ItemHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_ItemWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"ItemWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::ItemWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_MaximumRowsOrColumnsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"MaximumRowsOrColumnsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::MaximumRowsOrColumnsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_RowSpanProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"RowSpanProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::RowSpanProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VariableSizedWrapGrid_get_VerticalChildrenAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid", L"VerticalChildrenAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid::VerticalChildrenAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_VariableSizedWrapGrid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_VariableSizedWrapGrid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_VariableSizedWrapGrid[] = {
        { "_assign_array_", _assign_array_VariableSizedWrapGrid, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_VariableSizedWrapGrid), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_VariableSizedWrapGrid[] = {
        { "vertical_children_alignment", reinterpret_cast<getter>(VariableSizedWrapGrid_get_VerticalChildrenAlignment), reinterpret_cast<setter>(VariableSizedWrapGrid_put_VerticalChildrenAlignment), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(VariableSizedWrapGrid_get_Orientation), reinterpret_cast<setter>(VariableSizedWrapGrid_put_Orientation), nullptr, nullptr },
        { "maximum_rows_or_columns", reinterpret_cast<getter>(VariableSizedWrapGrid_get_MaximumRowsOrColumns), reinterpret_cast<setter>(VariableSizedWrapGrid_put_MaximumRowsOrColumns), nullptr, nullptr },
        { "item_width", reinterpret_cast<getter>(VariableSizedWrapGrid_get_ItemWidth), reinterpret_cast<setter>(VariableSizedWrapGrid_put_ItemWidth), nullptr, nullptr },
        { "item_height", reinterpret_cast<getter>(VariableSizedWrapGrid_get_ItemHeight), reinterpret_cast<setter>(VariableSizedWrapGrid_put_ItemHeight), nullptr, nullptr },
        { "horizontal_children_alignment", reinterpret_cast<getter>(VariableSizedWrapGrid_get_HorizontalChildrenAlignment), reinterpret_cast<setter>(VariableSizedWrapGrid_put_HorizontalChildrenAlignment), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_VariableSizedWrapGrid[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_VariableSizedWrapGrid) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_VariableSizedWrapGrid) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_VariableSizedWrapGrid) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_VariableSizedWrapGrid) },
        { },
    };

    static PyType_Spec type_spec_VariableSizedWrapGrid =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.VariableSizedWrapGrid",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::VariableSizedWrapGrid),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_VariableSizedWrapGrid
    };

    static PyGetSetDef getset_VariableSizedWrapGrid_Static[] = {
        { "column_span_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_ColumnSpanProperty), nullptr, nullptr, nullptr },
        { "horizontal_children_alignment_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_HorizontalChildrenAlignmentProperty), nullptr, nullptr, nullptr },
        { "item_height_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_ItemHeightProperty), nullptr, nullptr, nullptr },
        { "item_width_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_ItemWidthProperty), nullptr, nullptr, nullptr },
        { "maximum_rows_or_columns_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_MaximumRowsOrColumnsProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "row_span_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_RowSpanProperty), nullptr, nullptr, nullptr },
        { "vertical_children_alignment_property", reinterpret_cast<getter>(VariableSizedWrapGrid_get_VerticalChildrenAlignmentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_VariableSizedWrapGrid_Static[] = {
        { "get_column_span", reinterpret_cast<PyCFunction>(VariableSizedWrapGrid_GetColumnSpan), METH_VARARGS, nullptr },
        { "get_row_span", reinterpret_cast<PyCFunction>(VariableSizedWrapGrid_GetRowSpan), METH_VARARGS, nullptr },
        { "set_column_span", reinterpret_cast<PyCFunction>(VariableSizedWrapGrid_SetColumnSpan), METH_VARARGS, nullptr },
        { "set_row_span", reinterpret_cast<PyCFunction>(VariableSizedWrapGrid_SetRowSpan), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_VariableSizedWrapGrid_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_VariableSizedWrapGrid_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_VariableSizedWrapGrid_Static) },
        { }
    };

    static PyType_Spec type_spec_VariableSizedWrapGrid_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.VariableSizedWrapGrid_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_VariableSizedWrapGrid_Static
    };

    // ----- Viewbox class --------------------

    static PyObject* _new_Viewbox(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::Microsoft::UI::Xaml::Controls::Viewbox 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_Viewbox(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* Viewbox_get_StretchDirection(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"StretchDirection"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.StretchDirection());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Viewbox_put_StretchDirection(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"StretchDirection"))
        {
            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::Microsoft::UI::Xaml::Controls::StretchDirection>(arg);

            self->obj.StretchDirection(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Viewbox_get_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"Stretch"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Stretch());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Viewbox_put_Stretch(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"Stretch"))
        {
            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::Microsoft::UI::Xaml::Media::Stretch>(arg);

            self->obj.Stretch(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Viewbox_get_Child(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"Child"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Child());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int Viewbox_put_Child(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"Child"))
        {
            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::Microsoft::UI::Xaml::UIElement>(arg);

            self->obj.Child(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* Viewbox_get_StretchDirectionProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"StretchDirectionProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Viewbox::StretchDirectionProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* Viewbox_get_StretchProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.Viewbox", L"StretchProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::Viewbox::StretchProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_Viewbox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::Viewbox>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Viewbox(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::Viewbox>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Viewbox[] = {
        { "_assign_array_", _assign_array_Viewbox, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Viewbox), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Viewbox[] = {
        { "stretch_direction", reinterpret_cast<getter>(Viewbox_get_StretchDirection), reinterpret_cast<setter>(Viewbox_put_StretchDirection), nullptr, nullptr },
        { "stretch", reinterpret_cast<getter>(Viewbox_get_Stretch), reinterpret_cast<setter>(Viewbox_put_Stretch), nullptr, nullptr },
        { "child", reinterpret_cast<getter>(Viewbox_get_Child), reinterpret_cast<setter>(Viewbox_put_Child), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Viewbox[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Viewbox) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Viewbox) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Viewbox) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Viewbox) },
        { },
    };

    static PyType_Spec type_spec_Viewbox =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Viewbox",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::Viewbox),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Viewbox
    };

    static PyGetSetDef getset_Viewbox_Static[] = {
        { "stretch_direction_property", reinterpret_cast<getter>(Viewbox_get_StretchDirectionProperty), nullptr, nullptr, nullptr },
        { "stretch_property", reinterpret_cast<getter>(Viewbox_get_StretchProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_Viewbox_Static[] = {
        { }
    };

    static PyType_Slot type_slots_Viewbox_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_Viewbox_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_Viewbox_Static) },
        { }
    };

    static PyType_Spec type_spec_Viewbox_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.Viewbox_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_Viewbox_Static
    };

    // ----- VirtualizingLayout class --------------------

    static PyObject* _new_VirtualizingLayout(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::Microsoft::UI::Xaml::Controls::VirtualizingLayout 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_VirtualizingLayout(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayout* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* _assign_array_VirtualizingLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::VirtualizingLayout>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_VirtualizingLayout(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::VirtualizingLayout>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_VirtualizingLayout[] = {
        { "_assign_array_", _assign_array_VirtualizingLayout, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_VirtualizingLayout), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_VirtualizingLayout[] = {
        { }
    };

    static PyType_Slot _type_slots_VirtualizingLayout[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_VirtualizingLayout) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_VirtualizingLayout) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_VirtualizingLayout) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_VirtualizingLayout) },
        { },
    };

    static PyType_Spec type_spec_VirtualizingLayout =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.VirtualizingLayout",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayout),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_VirtualizingLayout
    };

    // ----- VirtualizingLayoutContext class --------------------

    static PyObject* _new_VirtualizingLayoutContext(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::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext 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_VirtualizingLayoutContext(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* VirtualizingLayoutContext_GetItemAt(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"GetItemAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.GetItemAt(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VirtualizingLayoutContext_GetOrCreateElementAt(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"GetOrCreateElementAt", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.GetOrCreateElementAt(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"GetOrCreateElementAt", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::ElementRealizationOptions>(args, 1);

                return py::convert(self->obj.GetOrCreateElementAt(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VirtualizingLayoutContext_RecycleElement(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"RecycleElement", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.RecycleElement(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VirtualizingLayoutContext_get_LayoutOrigin(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"LayoutOrigin"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.LayoutOrigin());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VirtualizingLayoutContext_put_LayoutOrigin(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"LayoutOrigin"))
        {
            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::Point>(arg);

            self->obj.LayoutOrigin(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VirtualizingLayoutContext_get_ItemCount(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"ItemCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemCount());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingLayoutContext_get_RealizationRect(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"RealizationRect"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RealizationRect());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingLayoutContext_get_RecommendedAnchorIndex(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"RecommendedAnchorIndex"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RecommendedAnchorIndex());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingLayoutContext_get_VisibleRect(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext", L"VisibleRect"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VisibleRect());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_VirtualizingLayoutContext(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_VirtualizingLayoutContext(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_VirtualizingLayoutContext[] = {
        { "get_item_at", reinterpret_cast<PyCFunction>(VirtualizingLayoutContext_GetItemAt), METH_VARARGS, nullptr },
        { "get_or_create_element_at", reinterpret_cast<PyCFunction>(VirtualizingLayoutContext_GetOrCreateElementAt), METH_VARARGS, nullptr },
        { "recycle_element", reinterpret_cast<PyCFunction>(VirtualizingLayoutContext_RecycleElement), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_VirtualizingLayoutContext, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_VirtualizingLayoutContext), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_VirtualizingLayoutContext[] = {
        { "layout_origin", reinterpret_cast<getter>(VirtualizingLayoutContext_get_LayoutOrigin), reinterpret_cast<setter>(VirtualizingLayoutContext_put_LayoutOrigin), nullptr, nullptr },
        { "item_count", reinterpret_cast<getter>(VirtualizingLayoutContext_get_ItemCount), nullptr, nullptr, nullptr },
        { "realization_rect", reinterpret_cast<getter>(VirtualizingLayoutContext_get_RealizationRect), nullptr, nullptr, nullptr },
        { "recommended_anchor_index", reinterpret_cast<getter>(VirtualizingLayoutContext_get_RecommendedAnchorIndex), nullptr, nullptr, nullptr },
        { "visible_rect", reinterpret_cast<getter>(VirtualizingLayoutContext_get_VisibleRect), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_VirtualizingLayoutContext[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_VirtualizingLayoutContext) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_VirtualizingLayoutContext) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_VirtualizingLayoutContext) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_VirtualizingLayoutContext) },
        { },
    };

    static PyType_Spec type_spec_VirtualizingLayoutContext =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.VirtualizingLayoutContext",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingLayoutContext),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_VirtualizingLayoutContext
    };

    // ----- VirtualizingPanel class --------------------

    static PyObject* _new_VirtualizingPanel(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::VirtualizingPanel>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::VirtualizingPanel>::type_name);
        return nullptr;
    }

    static void _dealloc_VirtualizingPanel(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingPanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* VirtualizingPanel_get_ItemContainerGenerator(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingPanel", L"ItemContainerGenerator"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemContainerGenerator());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_VirtualizingPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::VirtualizingPanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_VirtualizingPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::VirtualizingPanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_VirtualizingPanel[] = {
        { "_assign_array_", _assign_array_VirtualizingPanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_VirtualizingPanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_VirtualizingPanel[] = {
        { "item_container_generator", reinterpret_cast<getter>(VirtualizingPanel_get_ItemContainerGenerator), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_VirtualizingPanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_VirtualizingPanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_VirtualizingPanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_VirtualizingPanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_VirtualizingPanel) },
        { },
    };

    static PyType_Spec type_spec_VirtualizingPanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.VirtualizingPanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingPanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_VirtualizingPanel
    };

    // ----- VirtualizingStackPanel class --------------------

    static PyObject* _new_VirtualizingStackPanel(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::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel 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_VirtualizingStackPanel(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* VirtualizingStackPanel_GetIsVirtualizing(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"GetIsVirtualizing", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel::GetIsVirtualizing(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_GetVirtualizationMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"GetVirtualizationMode", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel::GetVirtualizationMode(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_SetVirtualizationMode(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"SetVirtualizationMode", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::VirtualizationMode>(args, 1);

                winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel::SetVirtualizationMode(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VirtualizingStackPanel_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VirtualizingStackPanel_get_AreScrollSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"AreScrollSnapPointsRegular"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.AreScrollSnapPointsRegular());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int VirtualizingStackPanel_put_AreScrollSnapPointsRegular(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"AreScrollSnapPointsRegular"))
        {
            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.AreScrollSnapPointsRegular(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* VirtualizingStackPanel_get_AreScrollSnapPointsRegularProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"AreScrollSnapPointsRegularProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel::AreScrollSnapPointsRegularProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_get_IsVirtualizingProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"IsVirtualizingProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel::IsVirtualizingProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_get_VirtualizationModeProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"VirtualizationModeProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel::VirtualizationModeProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_add_CleanUpVirtualizedItemEvent(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"CleanUpVirtualizedItemEvent"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::CleanUpVirtualizedItemEventHandler>(arg);

            return py::convert(self->obj.CleanUpVirtualizedItemEvent(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* VirtualizingStackPanel_remove_CleanUpVirtualizedItemEvent(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.VirtualizingStackPanel", L"CleanUpVirtualizedItemEvent"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CleanUpVirtualizedItemEvent(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_VirtualizingStackPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_VirtualizingStackPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_VirtualizingStackPanel[] = {
        { "add_clean_up_virtualized_item_event", reinterpret_cast<PyCFunction>(VirtualizingStackPanel_add_CleanUpVirtualizedItemEvent), METH_O, nullptr },
        { "remove_clean_up_virtualized_item_event", reinterpret_cast<PyCFunction>(VirtualizingStackPanel_remove_CleanUpVirtualizedItemEvent), METH_O, nullptr },
        { "_assign_array_", _assign_array_VirtualizingStackPanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_VirtualizingStackPanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_VirtualizingStackPanel[] = {
        { "orientation", reinterpret_cast<getter>(VirtualizingStackPanel_get_Orientation), reinterpret_cast<setter>(VirtualizingStackPanel_put_Orientation), nullptr, nullptr },
        { "are_scroll_snap_points_regular", reinterpret_cast<getter>(VirtualizingStackPanel_get_AreScrollSnapPointsRegular), reinterpret_cast<setter>(VirtualizingStackPanel_put_AreScrollSnapPointsRegular), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_VirtualizingStackPanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_VirtualizingStackPanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_VirtualizingStackPanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_VirtualizingStackPanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_VirtualizingStackPanel) },
        { },
    };

    static PyType_Spec type_spec_VirtualizingStackPanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.VirtualizingStackPanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::VirtualizingStackPanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_VirtualizingStackPanel
    };

    static PyGetSetDef getset_VirtualizingStackPanel_Static[] = {
        { "are_scroll_snap_points_regular_property", reinterpret_cast<getter>(VirtualizingStackPanel_get_AreScrollSnapPointsRegularProperty), nullptr, nullptr, nullptr },
        { "is_virtualizing_property", reinterpret_cast<getter>(VirtualizingStackPanel_get_IsVirtualizingProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(VirtualizingStackPanel_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "virtualization_mode_property", reinterpret_cast<getter>(VirtualizingStackPanel_get_VirtualizationModeProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_VirtualizingStackPanel_Static[] = {
        { "get_is_virtualizing", reinterpret_cast<PyCFunction>(VirtualizingStackPanel_GetIsVirtualizing), METH_VARARGS, nullptr },
        { "get_virtualization_mode", reinterpret_cast<PyCFunction>(VirtualizingStackPanel_GetVirtualizationMode), METH_VARARGS, nullptr },
        { "set_virtualization_mode", reinterpret_cast<PyCFunction>(VirtualizingStackPanel_SetVirtualizationMode), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_VirtualizingStackPanel_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_VirtualizingStackPanel_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_VirtualizingStackPanel_Static) },
        { }
    };

    static PyType_Spec type_spec_VirtualizingStackPanel_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.VirtualizingStackPanel_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_VirtualizingStackPanel_Static
    };

    // ----- WebView2 class --------------------

    static PyObject* _new_WebView2(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::Microsoft::UI::Xaml::Controls::WebView2 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_WebView2(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* WebView2_Close(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* WebView2_EnsureCoreWebView2Async(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"EnsureCoreWebView2Async", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.EnsureCoreWebView2Async());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"EnsureCoreWebView2Async", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::Web::WebView2::Core::CoreWebView2Environment>(args, 0);

                return py::convert(self->obj.EnsureCoreWebView2Async(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"EnsureCoreWebView2Async", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::Web::WebView2::Core::CoreWebView2Environment>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::Web::WebView2::Core::CoreWebView2ControllerOptions>(args, 1);

                return py::convert(self->obj.EnsureCoreWebView2Async(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* WebView2_ExecuteScriptAsync(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"ExecuteScriptAsync", 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.ExecuteScriptAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* WebView2_GoBack(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"GoBack", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.GoBack();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* WebView2_GoForward(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"GoForward", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.GoForward();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* WebView2_NavigateToString(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"NavigateToString", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                self->obj.NavigateToString(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* WebView2_Reload(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"Reload", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Reload();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* WebView2_get_Source(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"Source"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Source());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WebView2_put_Source(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"Source"))
        {
            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::Uri>(arg);

            self->obj.Source(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WebView2_get_DefaultBackgroundColor(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"DefaultBackgroundColor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DefaultBackgroundColor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WebView2_put_DefaultBackgroundColor(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"DefaultBackgroundColor"))
        {
            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::UI::Color>(arg);

            self->obj.DefaultBackgroundColor(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WebView2_get_CanGoForward(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CanGoForward"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanGoForward());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WebView2_put_CanGoForward(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CanGoForward"))
        {
            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.CanGoForward(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WebView2_get_CanGoBack(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CanGoBack"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CanGoBack());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WebView2_put_CanGoBack(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CanGoBack"))
        {
            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.CanGoBack(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WebView2_get_CoreWebView2(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CoreWebView2"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CoreWebView2());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_get_CanGoBackProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CanGoBackProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WebView2::CanGoBackProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_get_CanGoForwardProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CanGoForwardProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WebView2::CanGoForwardProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_get_DefaultBackgroundColorProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"DefaultBackgroundColorProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WebView2::DefaultBackgroundColorProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_get_SourceProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"SourceProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WebView2::SourceProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_add_CoreProcessFailed(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CoreProcessFailed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::WebView2, winrt::Microsoft::Web::WebView2::Core::CoreWebView2ProcessFailedEventArgs>>(arg);

            return py::convert(self->obj.CoreProcessFailed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_remove_CoreProcessFailed(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CoreProcessFailed"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CoreProcessFailed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_add_CoreWebView2Initialized(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CoreWebView2Initialized"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::WebView2, winrt::Microsoft::UI::Xaml::Controls::CoreWebView2InitializedEventArgs>>(arg);

            return py::convert(self->obj.CoreWebView2Initialized(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_remove_CoreWebView2Initialized(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"CoreWebView2Initialized"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.CoreWebView2Initialized(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_add_NavigationCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"NavigationCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::WebView2, winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationCompletedEventArgs>>(arg);

            return py::convert(self->obj.NavigationCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_remove_NavigationCompleted(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"NavigationCompleted"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.NavigationCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_add_NavigationStarting(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"NavigationStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::WebView2, winrt::Microsoft::Web::WebView2::Core::CoreWebView2NavigationStartingEventArgs>>(arg);

            return py::convert(self->obj.NavigationStarting(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_remove_NavigationStarting(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"NavigationStarting"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.NavigationStarting(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_add_WebMessageReceived(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"WebMessageReceived"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::WebView2, winrt::Microsoft::Web::WebView2::Core::CoreWebView2WebMessageReceivedEventArgs>>(arg);

            return py::convert(self->obj.WebMessageReceived(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WebView2_remove_WebMessageReceived(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.WebView2", L"WebMessageReceived"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.WebMessageReceived(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_WebView2(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::WebView2>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_WebView2(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::WebView2>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_WebView2[] = {
        { "close", reinterpret_cast<PyCFunction>(WebView2_Close), METH_VARARGS, nullptr },
        { "ensure_core_web_view2_async", reinterpret_cast<PyCFunction>(WebView2_EnsureCoreWebView2Async), METH_VARARGS, nullptr },
        { "execute_script_async", reinterpret_cast<PyCFunction>(WebView2_ExecuteScriptAsync), METH_VARARGS, nullptr },
        { "go_back", reinterpret_cast<PyCFunction>(WebView2_GoBack), METH_VARARGS, nullptr },
        { "go_forward", reinterpret_cast<PyCFunction>(WebView2_GoForward), METH_VARARGS, nullptr },
        { "navigate_to_string", reinterpret_cast<PyCFunction>(WebView2_NavigateToString), METH_VARARGS, nullptr },
        { "reload", reinterpret_cast<PyCFunction>(WebView2_Reload), METH_VARARGS, nullptr },
        { "add_core_process_failed", reinterpret_cast<PyCFunction>(WebView2_add_CoreProcessFailed), METH_O, nullptr },
        { "remove_core_process_failed", reinterpret_cast<PyCFunction>(WebView2_remove_CoreProcessFailed), METH_O, nullptr },
        { "add_core_web_view2_initialized", reinterpret_cast<PyCFunction>(WebView2_add_CoreWebView2Initialized), METH_O, nullptr },
        { "remove_core_web_view2_initialized", reinterpret_cast<PyCFunction>(WebView2_remove_CoreWebView2Initialized), METH_O, nullptr },
        { "add_navigation_completed", reinterpret_cast<PyCFunction>(WebView2_add_NavigationCompleted), METH_O, nullptr },
        { "remove_navigation_completed", reinterpret_cast<PyCFunction>(WebView2_remove_NavigationCompleted), METH_O, nullptr },
        { "add_navigation_starting", reinterpret_cast<PyCFunction>(WebView2_add_NavigationStarting), METH_O, nullptr },
        { "remove_navigation_starting", reinterpret_cast<PyCFunction>(WebView2_remove_NavigationStarting), METH_O, nullptr },
        { "add_web_message_received", reinterpret_cast<PyCFunction>(WebView2_add_WebMessageReceived), METH_O, nullptr },
        { "remove_web_message_received", reinterpret_cast<PyCFunction>(WebView2_remove_WebMessageReceived), METH_O, nullptr },
        { "_assign_array_", _assign_array_WebView2, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_WebView2), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_WebView2[] = {
        { "source", reinterpret_cast<getter>(WebView2_get_Source), reinterpret_cast<setter>(WebView2_put_Source), nullptr, nullptr },
        { "default_background_color", reinterpret_cast<getter>(WebView2_get_DefaultBackgroundColor), reinterpret_cast<setter>(WebView2_put_DefaultBackgroundColor), nullptr, nullptr },
        { "can_go_forward", reinterpret_cast<getter>(WebView2_get_CanGoForward), reinterpret_cast<setter>(WebView2_put_CanGoForward), nullptr, nullptr },
        { "can_go_back", reinterpret_cast<getter>(WebView2_get_CanGoBack), reinterpret_cast<setter>(WebView2_put_CanGoBack), nullptr, nullptr },
        { "core_web_view2", reinterpret_cast<getter>(WebView2_get_CoreWebView2), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_WebView2[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_WebView2) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_WebView2) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_WebView2) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_WebView2) },
        { },
    };

    static PyType_Spec type_spec_WebView2 =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.WebView2",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::WebView2),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_WebView2
    };

    static PyGetSetDef getset_WebView2_Static[] = {
        { "can_go_back_property", reinterpret_cast<getter>(WebView2_get_CanGoBackProperty), nullptr, nullptr, nullptr },
        { "can_go_forward_property", reinterpret_cast<getter>(WebView2_get_CanGoForwardProperty), nullptr, nullptr, nullptr },
        { "default_background_color_property", reinterpret_cast<getter>(WebView2_get_DefaultBackgroundColorProperty), nullptr, nullptr, nullptr },
        { "source_property", reinterpret_cast<getter>(WebView2_get_SourceProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_WebView2_Static[] = {
        { }
    };

    static PyType_Slot type_slots_WebView2_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_WebView2_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_WebView2_Static) },
        { }
    };

    static PyType_Spec type_spec_WebView2_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.WebView2_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_WebView2_Static
    };

    // ----- WrapGrid class --------------------

    static PyObject* _new_WrapGrid(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::Microsoft::UI::Xaml::Controls::WrapGrid 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_WrapGrid(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* WrapGrid_get_VerticalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"VerticalChildrenAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.VerticalChildrenAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WrapGrid_put_VerticalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"VerticalChildrenAlignment"))
        {
            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::Microsoft::UI::Xaml::VerticalAlignment>(arg);

            self->obj.VerticalChildrenAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WrapGrid_get_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"Orientation"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Orientation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WrapGrid_put_Orientation(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"Orientation"))
        {
            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::Microsoft::UI::Xaml::Controls::Orientation>(arg);

            self->obj.Orientation(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WrapGrid_get_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"MaximumRowsOrColumns"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.MaximumRowsOrColumns());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WrapGrid_put_MaximumRowsOrColumns(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"MaximumRowsOrColumns"))
        {
            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<int32_t>(arg);

            self->obj.MaximumRowsOrColumns(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WrapGrid_get_ItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"ItemWidth"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemWidth());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WrapGrid_put_ItemWidth(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"ItemWidth"))
        {
            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<double>(arg);

            self->obj.ItemWidth(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WrapGrid_get_ItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"ItemHeight"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.ItemHeight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WrapGrid_put_ItemHeight(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"ItemHeight"))
        {
            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<double>(arg);

            self->obj.ItemHeight(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WrapGrid_get_HorizontalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"HorizontalChildrenAlignment"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.HorizontalChildrenAlignment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int WrapGrid_put_HorizontalChildrenAlignment(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"HorizontalChildrenAlignment"))
        {
            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::Microsoft::UI::Xaml::HorizontalAlignment>(arg);

            self->obj.HorizontalChildrenAlignment(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* WrapGrid_get_HorizontalChildrenAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"HorizontalChildrenAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WrapGrid::HorizontalChildrenAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WrapGrid_get_ItemHeightProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"ItemHeightProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WrapGrid::ItemHeightProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WrapGrid_get_ItemWidthProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"ItemWidthProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WrapGrid::ItemWidthProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WrapGrid_get_MaximumRowsOrColumnsProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"MaximumRowsOrColumnsProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WrapGrid::MaximumRowsOrColumnsProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WrapGrid_get_OrientationProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"OrientationProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WrapGrid::OrientationProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WrapGrid_get_VerticalChildrenAlignmentProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.WrapGrid", L"VerticalChildrenAlignmentProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::WrapGrid::VerticalChildrenAlignmentProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_WrapGrid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::WrapGrid>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_WrapGrid(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::WrapGrid>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_WrapGrid[] = {
        { "_assign_array_", _assign_array_WrapGrid, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_WrapGrid), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_WrapGrid[] = {
        { "vertical_children_alignment", reinterpret_cast<getter>(WrapGrid_get_VerticalChildrenAlignment), reinterpret_cast<setter>(WrapGrid_put_VerticalChildrenAlignment), nullptr, nullptr },
        { "orientation", reinterpret_cast<getter>(WrapGrid_get_Orientation), reinterpret_cast<setter>(WrapGrid_put_Orientation), nullptr, nullptr },
        { "maximum_rows_or_columns", reinterpret_cast<getter>(WrapGrid_get_MaximumRowsOrColumns), reinterpret_cast<setter>(WrapGrid_put_MaximumRowsOrColumns), nullptr, nullptr },
        { "item_width", reinterpret_cast<getter>(WrapGrid_get_ItemWidth), reinterpret_cast<setter>(WrapGrid_put_ItemWidth), nullptr, nullptr },
        { "item_height", reinterpret_cast<getter>(WrapGrid_get_ItemHeight), reinterpret_cast<setter>(WrapGrid_put_ItemHeight), nullptr, nullptr },
        { "horizontal_children_alignment", reinterpret_cast<getter>(WrapGrid_get_HorizontalChildrenAlignment), reinterpret_cast<setter>(WrapGrid_put_HorizontalChildrenAlignment), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_WrapGrid[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_WrapGrid) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_WrapGrid) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_WrapGrid) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_WrapGrid) },
        { },
    };

    static PyType_Spec type_spec_WrapGrid =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.WrapGrid",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::WrapGrid),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_WrapGrid
    };

    static PyGetSetDef getset_WrapGrid_Static[] = {
        { "horizontal_children_alignment_property", reinterpret_cast<getter>(WrapGrid_get_HorizontalChildrenAlignmentProperty), nullptr, nullptr, nullptr },
        { "item_height_property", reinterpret_cast<getter>(WrapGrid_get_ItemHeightProperty), nullptr, nullptr, nullptr },
        { "item_width_property", reinterpret_cast<getter>(WrapGrid_get_ItemWidthProperty), nullptr, nullptr, nullptr },
        { "maximum_rows_or_columns_property", reinterpret_cast<getter>(WrapGrid_get_MaximumRowsOrColumnsProperty), nullptr, nullptr, nullptr },
        { "orientation_property", reinterpret_cast<getter>(WrapGrid_get_OrientationProperty), nullptr, nullptr, nullptr },
        { "vertical_children_alignment_property", reinterpret_cast<getter>(WrapGrid_get_VerticalChildrenAlignmentProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_WrapGrid_Static[] = {
        { }
    };

    static PyType_Slot type_slots_WrapGrid_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_WrapGrid_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_WrapGrid_Static) },
        { }
    };

    static PyType_Spec type_spec_WrapGrid_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.WrapGrid_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_WrapGrid_Static
    };

    // ----- XamlControlsResources class --------------------

    static PyObject* _new_XamlControlsResources(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::Microsoft::UI::Xaml::Controls::XamlControlsResources 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_XamlControlsResources(py::wrapper::Microsoft::UI::Xaml::Controls::XamlControlsResources* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* XamlControlsResources_EnsureRevealLights(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.XamlControlsResources", L"EnsureRevealLights", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                winrt::Microsoft::UI::Xaml::Controls::XamlControlsResources::EnsureRevealLights(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* XamlControlsResources_get_UseCompactResources(py::wrapper::Microsoft::UI::Xaml::Controls::XamlControlsResources* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.XamlControlsResources", L"UseCompactResources"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.UseCompactResources());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int XamlControlsResources_put_UseCompactResources(py::wrapper::Microsoft::UI::Xaml::Controls::XamlControlsResources* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.XamlControlsResources", L"UseCompactResources"))
        {
            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.UseCompactResources(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* XamlControlsResources_get_UseCompactResourcesProperty(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.XamlControlsResources", L"UseCompactResourcesProperty"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(winrt::Microsoft::UI::Xaml::Controls::XamlControlsResources::UseCompactResourcesProperty());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_XamlControlsResources(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::XamlControlsResources>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_XamlControlsResources(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::XamlControlsResources>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_XamlControlsResources[] = {
        { "_assign_array_", _assign_array_XamlControlsResources, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_XamlControlsResources), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_XamlControlsResources[] = {
        { "use_compact_resources", reinterpret_cast<getter>(XamlControlsResources_get_UseCompactResources), reinterpret_cast<setter>(XamlControlsResources_put_UseCompactResources), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_XamlControlsResources[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_XamlControlsResources) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_XamlControlsResources) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_XamlControlsResources) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_XamlControlsResources) },
        { },
    };

    static PyType_Spec type_spec_XamlControlsResources =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.XamlControlsResources",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::XamlControlsResources),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_XamlControlsResources
    };

    static PyGetSetDef getset_XamlControlsResources_Static[] = {
        { "use_compact_resources_property", reinterpret_cast<getter>(XamlControlsResources_get_UseCompactResourcesProperty), nullptr, nullptr, nullptr },
        { }
    };

    static PyMethodDef methods_XamlControlsResources_Static[] = {
        { "ensure_reveal_lights", reinterpret_cast<PyCFunction>(XamlControlsResources_EnsureRevealLights), METH_VARARGS, nullptr },
        { }
    };

    static PyType_Slot type_slots_XamlControlsResources_Static[] = 
    {
        { Py_tp_base, reinterpret_cast<void*>(&PyType_Type) },
        { Py_tp_getset, reinterpret_cast<void*>(getset_XamlControlsResources_Static) },
        { Py_tp_methods, reinterpret_cast<void*>(methods_XamlControlsResources_Static) },
        { }
    };

    static PyType_Spec type_spec_XamlControlsResources_Static =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.XamlControlsResources_Static",
        static_cast<int>(PyType_Type.tp_basicsize),
        static_cast<int>(PyType_Type.tp_itemsize),
        Py_TPFLAGS_DEFAULT,
        type_slots_XamlControlsResources_Static
    };

    // ----- IAnimatedVisual interface --------------------

    static PyObject* _new_IAnimatedVisual(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual>::type_name);
        return nullptr;
    }

    static void _dealloc_IAnimatedVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IAnimatedVisual_Close(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Foundation.IClosable", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual_get_Duration(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual", L"Duration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Duration());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual_get_RootVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual", L"RootVisual"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RootVisual());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual", 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_IAnimatedVisual(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IAnimatedVisual(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_IAnimatedVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_IAnimatedVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IAnimatedVisual[] = {
        { "close", reinterpret_cast<PyCFunction>(IAnimatedVisual_Close), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IAnimatedVisual, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IAnimatedVisual), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_IAnimatedVisual), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_IAnimatedVisual), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_IAnimatedVisual[] = {
        { "duration", reinterpret_cast<getter>(IAnimatedVisual_get_Duration), nullptr, nullptr, nullptr },
        { "root_visual", reinterpret_cast<getter>(IAnimatedVisual_get_RootVisual), nullptr, nullptr, nullptr },
        { "size", reinterpret_cast<getter>(IAnimatedVisual_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IAnimatedVisual[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IAnimatedVisual) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IAnimatedVisual) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IAnimatedVisual) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IAnimatedVisual) },
        { },
    };

    static PyType_Spec type_spec_IAnimatedVisual =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IAnimatedVisual",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IAnimatedVisual
    };

    // ----- IAnimatedVisual2 interface --------------------

    static PyObject* _new_IAnimatedVisual2(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual2>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual2>::type_name);
        return nullptr;
    }

    static void _dealloc_IAnimatedVisual2(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IAnimatedVisual2_Close(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Foundation.IClosable", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual2_CreateAnimations(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual2", L"CreateAnimations", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CreateAnimations();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual2_DestroyAnimations(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual2", L"DestroyAnimations", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.DestroyAnimations();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual2_get_Duration(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual", L"Duration"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Duration());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual2_get_RootVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual", L"RootVisual"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.RootVisual());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisual2_get_Size(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisual", 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_IAnimatedVisual2(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual2>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IAnimatedVisual2(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisual2>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_IAnimatedVisual2(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_IAnimatedVisual2(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IAnimatedVisual2[] = {
        { "close", reinterpret_cast<PyCFunction>(IAnimatedVisual2_Close), METH_VARARGS, nullptr },
        { "create_animations", reinterpret_cast<PyCFunction>(IAnimatedVisual2_CreateAnimations), METH_VARARGS, nullptr },
        { "destroy_animations", reinterpret_cast<PyCFunction>(IAnimatedVisual2_DestroyAnimations), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IAnimatedVisual2, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IAnimatedVisual2), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_IAnimatedVisual2), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_IAnimatedVisual2), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_IAnimatedVisual2[] = {
        { "duration", reinterpret_cast<getter>(IAnimatedVisual2_get_Duration), nullptr, nullptr, nullptr },
        { "root_visual", reinterpret_cast<getter>(IAnimatedVisual2_get_RootVisual), nullptr, nullptr, nullptr },
        { "size", reinterpret_cast<getter>(IAnimatedVisual2_get_Size), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IAnimatedVisual2[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IAnimatedVisual2) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IAnimatedVisual2) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IAnimatedVisual2) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IAnimatedVisual2) },
        { },
    };

    static PyType_Spec type_spec_IAnimatedVisual2 =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IAnimatedVisual2",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisual2),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IAnimatedVisual2
    };

    // ----- IAnimatedVisualSource interface --------------------

    static PyObject* _new_IAnimatedVisualSource(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource>::type_name);
        return nullptr;
    }

    static void _dealloc_IAnimatedVisualSource(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IAnimatedVisualSource_TryCreateAnimatedVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisualSource", L"TryCreateAnimatedVisual", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Composition::Compositor>(args, 0);
                winrt::Windows::Foundation::IInspectable param1 {  };

                auto return_value = self->obj.TryCreateAnimatedVisual(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* _assign_array_IAnimatedVisualSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IAnimatedVisualSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IAnimatedVisualSource[] = {
        { "try_create_animated_visual", reinterpret_cast<PyCFunction>(IAnimatedVisualSource_TryCreateAnimatedVisual), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IAnimatedVisualSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IAnimatedVisualSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IAnimatedVisualSource[] = {
        { }
    };

    static PyType_Slot _type_slots_IAnimatedVisualSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IAnimatedVisualSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IAnimatedVisualSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IAnimatedVisualSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IAnimatedVisualSource) },
        { },
    };

    static PyType_Spec type_spec_IAnimatedVisualSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IAnimatedVisualSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IAnimatedVisualSource
    };

    // ----- IAnimatedVisualSource2 interface --------------------

    static PyObject* _new_IAnimatedVisualSource2(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2>::type_name);
        return nullptr;
    }

    static void _dealloc_IAnimatedVisualSource2(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IAnimatedVisualSource2_SetColorProperty(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2", L"SetColorProperty", 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::UI::Color>(args, 1);

                self->obj.SetColorProperty(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IAnimatedVisualSource2_TryCreateAnimatedVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisualSource", L"TryCreateAnimatedVisual", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Composition::Compositor>(args, 0);
                winrt::Windows::Foundation::IInspectable param1 {  };

                auto return_value = self->obj.TryCreateAnimatedVisual(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* IAnimatedVisualSource2_get_Markers(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2", L"Markers"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.Markers());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_IAnimatedVisualSource2(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IAnimatedVisualSource2(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IAnimatedVisualSource2[] = {
        { "set_color_property", reinterpret_cast<PyCFunction>(IAnimatedVisualSource2_SetColorProperty), METH_VARARGS, nullptr },
        { "try_create_animated_visual", reinterpret_cast<PyCFunction>(IAnimatedVisualSource2_TryCreateAnimatedVisual), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IAnimatedVisualSource2, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IAnimatedVisualSource2), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IAnimatedVisualSource2[] = {
        { "markers", reinterpret_cast<getter>(IAnimatedVisualSource2_get_Markers), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IAnimatedVisualSource2[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IAnimatedVisualSource2) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IAnimatedVisualSource2) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IAnimatedVisualSource2) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IAnimatedVisualSource2) },
        { },
    };

    static PyType_Spec type_spec_IAnimatedVisualSource2 =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IAnimatedVisualSource2",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource2),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IAnimatedVisualSource2
    };

    // ----- IAnimatedVisualSource3 interface --------------------

    static PyObject* _new_IAnimatedVisualSource3(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource3>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource3>::type_name);
        return nullptr;
    }

    static void _dealloc_IAnimatedVisualSource3(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource3* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IAnimatedVisualSource3_TryCreateAnimatedVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource3* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisualSource3", L"TryCreateAnimatedVisual", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Composition::Compositor>(args, 0);
                winrt::Windows::Foundation::IInspectable param1 {  };
                auto param2 = py::convert_to<bool>(args, 2);

                auto return_value = self->obj.TryCreateAnimatedVisual(param0, param1, param2);

                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* _assign_array_IAnimatedVisualSource3(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource3>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IAnimatedVisualSource3(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource3>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IAnimatedVisualSource3[] = {
        { "try_create_animated_visual", reinterpret_cast<PyCFunction>(IAnimatedVisualSource3_TryCreateAnimatedVisual), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IAnimatedVisualSource3, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IAnimatedVisualSource3), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IAnimatedVisualSource3[] = {
        { }
    };

    static PyType_Slot _type_slots_IAnimatedVisualSource3[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IAnimatedVisualSource3) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IAnimatedVisualSource3) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IAnimatedVisualSource3) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IAnimatedVisualSource3) },
        { },
    };

    static PyType_Spec type_spec_IAnimatedVisualSource3 =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IAnimatedVisualSource3",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IAnimatedVisualSource3),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IAnimatedVisualSource3
    };

    // ----- ICommandBarElement interface --------------------

    static PyObject* _new_ICommandBarElement(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ICommandBarElement>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ICommandBarElement>::type_name);
        return nullptr;
    }

    static void _dealloc_ICommandBarElement(py::wrapper::Microsoft::UI::Xaml::Controls::ICommandBarElement* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ICommandBarElement_get_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::ICommandBarElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ICommandBarElement", L"DynamicOverflowOrder"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.DynamicOverflowOrder());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ICommandBarElement_put_DynamicOverflowOrder(py::wrapper::Microsoft::UI::Xaml::Controls::ICommandBarElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ICommandBarElement", L"DynamicOverflowOrder"))
        {
            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<int32_t>(arg);

            self->obj.DynamicOverflowOrder(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ICommandBarElement_get_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::ICommandBarElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ICommandBarElement", L"IsCompact"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsCompact());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ICommandBarElement_put_IsCompact(py::wrapper::Microsoft::UI::Xaml::Controls::ICommandBarElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ICommandBarElement", L"IsCompact"))
        {
            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.IsCompact(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ICommandBarElement_get_IsInOverflow(py::wrapper::Microsoft::UI::Xaml::Controls::ICommandBarElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ICommandBarElement", L"IsInOverflow"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsInOverflow());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_ICommandBarElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ICommandBarElement>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ICommandBarElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ICommandBarElement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ICommandBarElement[] = {
        { "_assign_array_", _assign_array_ICommandBarElement, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ICommandBarElement), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ICommandBarElement[] = {
        { "dynamic_overflow_order", reinterpret_cast<getter>(ICommandBarElement_get_DynamicOverflowOrder), reinterpret_cast<setter>(ICommandBarElement_put_DynamicOverflowOrder), nullptr, nullptr },
        { "is_compact", reinterpret_cast<getter>(ICommandBarElement_get_IsCompact), reinterpret_cast<setter>(ICommandBarElement_put_IsCompact), nullptr, nullptr },
        { "is_in_overflow", reinterpret_cast<getter>(ICommandBarElement_get_IsInOverflow), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ICommandBarElement[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ICommandBarElement) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ICommandBarElement) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ICommandBarElement) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ICommandBarElement) },
        { },
    };

    static PyType_Spec type_spec_ICommandBarElement =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ICommandBarElement",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ICommandBarElement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ICommandBarElement
    };

    // ----- IDynamicAnimatedVisualSource interface --------------------

    static PyObject* _new_IDynamicAnimatedVisualSource(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource>::type_name);
        return nullptr;
    }

    static void _dealloc_IDynamicAnimatedVisualSource(py::wrapper::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IDynamicAnimatedVisualSource_TryCreateAnimatedVisual(py::wrapper::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IAnimatedVisualSource", L"TryCreateAnimatedVisual", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Composition::Compositor>(args, 0);
                winrt::Windows::Foundation::IInspectable param1 {  };

                auto return_value = self->obj.TryCreateAnimatedVisual(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* IDynamicAnimatedVisualSource_add_AnimatedVisualInvalidated(py::wrapper::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.IDynamicAnimatedVisualSource", L"AnimatedVisualInvalidated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.AnimatedVisualInvalidated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IDynamicAnimatedVisualSource_remove_AnimatedVisualInvalidated(py::wrapper::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Microsoft.UI.Xaml.Controls.IDynamicAnimatedVisualSource", L"AnimatedVisualInvalidated"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.AnimatedVisualInvalidated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_IDynamicAnimatedVisualSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IDynamicAnimatedVisualSource(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IDynamicAnimatedVisualSource[] = {
        { "try_create_animated_visual", reinterpret_cast<PyCFunction>(IDynamicAnimatedVisualSource_TryCreateAnimatedVisual), METH_VARARGS, nullptr },
        { "add_animated_visual_invalidated", reinterpret_cast<PyCFunction>(IDynamicAnimatedVisualSource_add_AnimatedVisualInvalidated), METH_O, nullptr },
        { "remove_animated_visual_invalidated", reinterpret_cast<PyCFunction>(IDynamicAnimatedVisualSource_remove_AnimatedVisualInvalidated), METH_O, nullptr },
        { "_assign_array_", _assign_array_IDynamicAnimatedVisualSource, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IDynamicAnimatedVisualSource), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IDynamicAnimatedVisualSource[] = {
        { }
    };

    static PyType_Slot _type_slots_IDynamicAnimatedVisualSource[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IDynamicAnimatedVisualSource) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IDynamicAnimatedVisualSource) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IDynamicAnimatedVisualSource) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IDynamicAnimatedVisualSource) },
        { },
    };

    static PyType_Spec type_spec_IDynamicAnimatedVisualSource =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IDynamicAnimatedVisualSource",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IDynamicAnimatedVisualSource),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IDynamicAnimatedVisualSource
    };

    // ----- IInsertionPanel interface --------------------

    static PyObject* _new_IInsertionPanel(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IInsertionPanel>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IInsertionPanel>::type_name);
        return nullptr;
    }

    static void _dealloc_IInsertionPanel(py::wrapper::Microsoft::UI::Xaml::Controls::IInsertionPanel* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IInsertionPanel_GetInsertionIndexes(py::wrapper::Microsoft::UI::Xaml::Controls::IInsertionPanel* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IInsertionPanel", L"GetInsertionIndexes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Point>(args, 0);
                int32_t param1 {  };
                int32_t param2 {  };

                self->obj.GetInsertionIndexes(param0, param1, param2);

                py::pyobj_handle out1{ py::convert(param1) };
                if (!out1)
                {
                    return nullptr;
                }
                py::pyobj_handle out2{ py::convert(param2) };
                if (!out2)
                {
                    return nullptr;
                }
                return PyTuple_Pack(2, out1.get(), out2.get());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_IInsertionPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IInsertionPanel>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IInsertionPanel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IInsertionPanel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IInsertionPanel[] = {
        { "get_insertion_indexes", reinterpret_cast<PyCFunction>(IInsertionPanel_GetInsertionIndexes), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IInsertionPanel, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IInsertionPanel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IInsertionPanel[] = {
        { }
    };

    static PyType_Slot _type_slots_IInsertionPanel[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IInsertionPanel) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IInsertionPanel) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IInsertionPanel) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IInsertionPanel) },
        { },
    };

    static PyType_Spec type_spec_IInsertionPanel =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IInsertionPanel",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IInsertionPanel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IInsertionPanel
    };

    // ----- IItemContainerMapping interface --------------------

    static PyObject* _new_IItemContainerMapping(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IItemContainerMapping>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IItemContainerMapping>::type_name);
        return nullptr;
    }

    static void _dealloc_IItemContainerMapping(py::wrapper::Microsoft::UI::Xaml::Controls::IItemContainerMapping* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IItemContainerMapping_ContainerFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::IItemContainerMapping* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IItemContainerMapping", L"ContainerFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.ContainerFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IItemContainerMapping_ContainerFromItem(py::wrapper::Microsoft::UI::Xaml::Controls::IItemContainerMapping* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IItemContainerMapping", L"ContainerFromItem", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::IInspectable>(args, 0);

                return py::convert(self->obj.ContainerFromItem(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IItemContainerMapping_IndexFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::IItemContainerMapping* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IItemContainerMapping", L"IndexFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.IndexFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IItemContainerMapping_ItemFromContainer(py::wrapper::Microsoft::UI::Xaml::Controls::IItemContainerMapping* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IItemContainerMapping", L"ItemFromContainer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::DependencyObject>(args, 0);

                return py::convert(self->obj.ItemFromContainer(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_IItemContainerMapping(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IItemContainerMapping>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IItemContainerMapping(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IItemContainerMapping>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IItemContainerMapping[] = {
        { "container_from_index", reinterpret_cast<PyCFunction>(IItemContainerMapping_ContainerFromIndex), METH_VARARGS, nullptr },
        { "container_from_item", reinterpret_cast<PyCFunction>(IItemContainerMapping_ContainerFromItem), METH_VARARGS, nullptr },
        { "index_from_container", reinterpret_cast<PyCFunction>(IItemContainerMapping_IndexFromContainer), METH_VARARGS, nullptr },
        { "item_from_container", reinterpret_cast<PyCFunction>(IItemContainerMapping_ItemFromContainer), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IItemContainerMapping, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IItemContainerMapping), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IItemContainerMapping[] = {
        { }
    };

    static PyType_Slot _type_slots_IItemContainerMapping[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IItemContainerMapping) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IItemContainerMapping) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IItemContainerMapping) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IItemContainerMapping) },
        { },
    };

    static PyType_Spec type_spec_IItemContainerMapping =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IItemContainerMapping",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IItemContainerMapping),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IItemContainerMapping
    };

    // ----- IKeyIndexMapping interface --------------------

    static PyObject* _new_IKeyIndexMapping(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IKeyIndexMapping>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IKeyIndexMapping>::type_name);
        return nullptr;
    }

    static void _dealloc_IKeyIndexMapping(py::wrapper::Microsoft::UI::Xaml::Controls::IKeyIndexMapping* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IKeyIndexMapping_IndexFromKey(py::wrapper::Microsoft::UI::Xaml::Controls::IKeyIndexMapping* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IKeyIndexMapping", L"IndexFromKey", 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.IndexFromKey(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IKeyIndexMapping_KeyFromIndex(py::wrapper::Microsoft::UI::Xaml::Controls::IKeyIndexMapping* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IKeyIndexMapping", L"KeyFromIndex", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);

                return py::convert(self->obj.KeyFromIndex(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_IKeyIndexMapping(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IKeyIndexMapping>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IKeyIndexMapping(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IKeyIndexMapping>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IKeyIndexMapping[] = {
        { "index_from_key", reinterpret_cast<PyCFunction>(IKeyIndexMapping_IndexFromKey), METH_VARARGS, nullptr },
        { "key_from_index", reinterpret_cast<PyCFunction>(IKeyIndexMapping_KeyFromIndex), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IKeyIndexMapping, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IKeyIndexMapping), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IKeyIndexMapping[] = {
        { }
    };

    static PyType_Slot _type_slots_IKeyIndexMapping[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IKeyIndexMapping) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IKeyIndexMapping) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IKeyIndexMapping) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IKeyIndexMapping) },
        { },
    };

    static PyType_Spec type_spec_IKeyIndexMapping =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IKeyIndexMapping",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IKeyIndexMapping),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IKeyIndexMapping
    };

    // ----- INavigate interface --------------------

    static PyObject* _new_INavigate(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::INavigate>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::INavigate>::type_name);
        return nullptr;
    }

    static void _dealloc_INavigate(py::wrapper::Microsoft::UI::Xaml::Controls::INavigate* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* INavigate_Navigate(py::wrapper::Microsoft::UI::Xaml::Controls::INavigate* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.INavigate", L"Navigate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::UI::Xaml::Interop::TypeName>(args, 0);

                return py::convert(self->obj.Navigate(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_INavigate(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::INavigate>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_INavigate(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::INavigate>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_INavigate[] = {
        { "navigate", reinterpret_cast<PyCFunction>(INavigate_Navigate), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_INavigate, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_INavigate), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_INavigate[] = {
        { }
    };

    static PyType_Slot _type_slots_INavigate[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_INavigate) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_INavigate) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_INavigate) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_INavigate) },
        { },
    };

    static PyType_Spec type_spec_INavigate =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.INavigate",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::INavigate),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_INavigate
    };

    // ----- IScrollAnchorProvider interface --------------------

    static PyObject* _new_IScrollAnchorProvider(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider>::type_name);
        return nullptr;
    }

    static void _dealloc_IScrollAnchorProvider(py::wrapper::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* IScrollAnchorProvider_RegisterAnchorCandidate(py::wrapper::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IScrollAnchorProvider", L"RegisterAnchorCandidate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.RegisterAnchorCandidate(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IScrollAnchorProvider_UnregisterAnchorCandidate(py::wrapper::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.IScrollAnchorProvider", L"UnregisterAnchorCandidate", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::UIElement>(args, 0);

                self->obj.UnregisterAnchorCandidate(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IScrollAnchorProvider_get_CurrentAnchor(py::wrapper::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.IScrollAnchorProvider", L"CurrentAnchor"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.CurrentAnchor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _assign_array_IScrollAnchorProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IScrollAnchorProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IScrollAnchorProvider[] = {
        { "register_anchor_candidate", reinterpret_cast<PyCFunction>(IScrollAnchorProvider_RegisterAnchorCandidate), METH_VARARGS, nullptr },
        { "unregister_anchor_candidate", reinterpret_cast<PyCFunction>(IScrollAnchorProvider_UnregisterAnchorCandidate), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IScrollAnchorProvider, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IScrollAnchorProvider), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IScrollAnchorProvider[] = {
        { "current_anchor", reinterpret_cast<getter>(IScrollAnchorProvider_get_CurrentAnchor), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IScrollAnchorProvider[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IScrollAnchorProvider) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IScrollAnchorProvider) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IScrollAnchorProvider) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IScrollAnchorProvider) },
        { },
    };

    static PyType_Spec type_spec_IScrollAnchorProvider =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.IScrollAnchorProvider",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::IScrollAnchorProvider),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IScrollAnchorProvider
    };

    // ----- ISemanticZoomInformation interface --------------------

    static PyObject* _new_ISemanticZoomInformation(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation>::type_name);
        return nullptr;
    }

    static void _dealloc_ISemanticZoomInformation(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* ISemanticZoomInformation_CompleteViewChange(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"CompleteViewChange", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.CompleteViewChange();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ISemanticZoomInformation_CompleteViewChangeFrom(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"CompleteViewChangeFrom", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.CompleteViewChangeFrom(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ISemanticZoomInformation_CompleteViewChangeTo(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"CompleteViewChangeTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.CompleteViewChangeTo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ISemanticZoomInformation_InitializeViewChange(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"InitializeViewChange", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                self->obj.InitializeViewChange();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ISemanticZoomInformation_MakeVisible(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"MakeVisible", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);

                self->obj.MakeVisible(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ISemanticZoomInformation_StartViewChangeFrom(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"StartViewChangeFrom", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.StartViewChangeFrom(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ISemanticZoomInformation_StartViewChangeTo(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"StartViewChangeTo", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 0);
                auto param1 = py::convert_to<winrt::Microsoft::UI::Xaml::Controls::SemanticZoomLocation>(args, 1);

                self->obj.StartViewChangeTo(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* ISemanticZoomInformation_get_IsActiveView(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"IsActiveView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsActiveView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISemanticZoomInformation_put_IsActiveView(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"IsActiveView"))
        {
            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.IsActiveView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISemanticZoomInformation_get_IsZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"IsZoomedInView"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.IsZoomedInView());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISemanticZoomInformation_put_IsZoomedInView(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"IsZoomedInView"))
        {
            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.IsZoomedInView(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* ISemanticZoomInformation_get_SemanticZoomOwner(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"SemanticZoomOwner"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            return py::convert(self->obj.SemanticZoomOwner());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int ISemanticZoomInformation_put_SemanticZoomOwner(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Microsoft.UI.Xaml.Controls.ISemanticZoomInformation", L"SemanticZoomOwner"))
        {
            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::Microsoft::UI::Xaml::Controls::SemanticZoom>(arg);

            self->obj.SemanticZoomOwner(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _assign_array_ISemanticZoomInformation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_ISemanticZoomInformation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_ISemanticZoomInformation[] = {
        { "complete_view_change", reinterpret_cast<PyCFunction>(ISemanticZoomInformation_CompleteViewChange), METH_VARARGS, nullptr },
        { "complete_view_change_from", reinterpret_cast<PyCFunction>(ISemanticZoomInformation_CompleteViewChangeFrom), METH_VARARGS, nullptr },
        { "complete_view_change_to", reinterpret_cast<PyCFunction>(ISemanticZoomInformation_CompleteViewChangeTo), METH_VARARGS, nullptr },
        { "initialize_view_change", reinterpret_cast<PyCFunction>(ISemanticZoomInformation_InitializeViewChange), METH_VARARGS, nullptr },
        { "make_visible", reinterpret_cast<PyCFunction>(ISemanticZoomInformation_MakeVisible), METH_VARARGS, nullptr },
        { "start_view_change_from", reinterpret_cast<PyCFunction>(ISemanticZoomInformation_StartViewChangeFrom), METH_VARARGS, nullptr },
        { "start_view_change_to", reinterpret_cast<PyCFunction>(ISemanticZoomInformation_StartViewChangeTo), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_ISemanticZoomInformation, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_ISemanticZoomInformation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_ISemanticZoomInformation[] = {
        { "is_active_view", reinterpret_cast<getter>(ISemanticZoomInformation_get_IsActiveView), reinterpret_cast<setter>(ISemanticZoomInformation_put_IsActiveView), nullptr, nullptr },
        { "is_zoomed_in_view", reinterpret_cast<getter>(ISemanticZoomInformation_get_IsZoomedInView), reinterpret_cast<setter>(ISemanticZoomInformation_put_IsZoomedInView), nullptr, nullptr },
        { "semantic_zoom_owner", reinterpret_cast<getter>(ISemanticZoomInformation_get_SemanticZoomOwner), reinterpret_cast<setter>(ISemanticZoomInformation_put_SemanticZoomOwner), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ISemanticZoomInformation[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_ISemanticZoomInformation) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_ISemanticZoomInformation) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_ISemanticZoomInformation) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_ISemanticZoomInformation) },
        { },
    };

    static PyType_Spec type_spec_ISemanticZoomInformation =
    {
        "winrt._winrt_microsoft_ui_xaml_controls.ISemanticZoomInformation",
        sizeof(py::wrapper::Microsoft::UI::Xaml::Controls::ISemanticZoomInformation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ISemanticZoomInformation
    };

    // ----- Microsoft.UI.Xaml.Controls Initialization --------------------
    PyDoc_STRVAR(module_doc, "Microsoft::UI::Xaml::Controls");


    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winrt_microsoft_ui_xaml_controls",
           module_doc,
           0,
           nullptr,
           nullptr,
           nullptr,
           nullptr,
           nullptr};

} // py::cpp::Microsoft::UI::Xaml::Controls

PyMODINIT_FUNC PyInit__winrt_microsoft_ui_xaml_controls(void) noexcept
{
    using namespace py::cpp::Microsoft::UI::Xaml::Controls;

    if (py::import_winrt_runtime() == -1)
    {
        return nullptr;
    }

    py::pyobj_handle module{PyModule_Create(&module_def)};

    if (!module)
    {
        return nullptr;
    }

    auto object_type = py::get_object_type();
    if (!object_type)
    {
        return nullptr;
    }

    py::pyobj_handle object_bases{PyTuple_Pack(1, object_type)};

    if (!object_bases)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnchorRequestedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AnimatedIcon_Static{PyType_FromSpec(&type_spec_AnimatedIcon_Static)};
    if (!type_AnimatedIcon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnimatedIcon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AnimatedIcon_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AnimatedIconSource_Static{PyType_FromSpec(&type_spec_AnimatedIconSource_Static)};
    if (!type_AnimatedIconSource_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnimatedIconSource, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AnimatedIconSource_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AnimatedVisualPlayer_Static{PyType_FromSpec(&type_spec_AnimatedVisualPlayer_Static)};
    if (!type_AnimatedVisualPlayer_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnimatedVisualPlayer, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AnimatedVisualPlayer_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AnnotatedScrollBar_Static{PyType_FromSpec(&type_spec_AnnotatedScrollBar_Static)};
    if (!type_AnnotatedScrollBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnnotatedScrollBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AnnotatedScrollBar_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnnotatedScrollBarDetailLabelRequestedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnnotatedScrollBarLabel, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AnnotatedScrollBarScrollingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AppBar_Static{PyType_FromSpec(&type_spec_AppBar_Static)};
    if (!type_AppBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AppBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AppBar_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AppBarButton_Static{PyType_FromSpec(&type_spec_AppBarButton_Static)};
    if (!type_AppBarButton_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AppBarButton, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AppBarButton_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AppBarElementContainer_Static{PyType_FromSpec(&type_spec_AppBarElementContainer_Static)};
    if (!type_AppBarElementContainer_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AppBarElementContainer, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AppBarElementContainer_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AppBarSeparator_Static{PyType_FromSpec(&type_spec_AppBarSeparator_Static)};
    if (!type_AppBarSeparator_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AppBarSeparator, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AppBarSeparator_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AppBarToggleButton_Static{PyType_FromSpec(&type_spec_AppBarToggleButton_Static)};
    if (!type_AppBarToggleButton_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AppBarToggleButton, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AppBarToggleButton_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AutoSuggestBox_Static{PyType_FromSpec(&type_spec_AutoSuggestBox_Static)};
    if (!type_AutoSuggestBox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AutoSuggestBox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AutoSuggestBox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AutoSuggestBoxQuerySubmittedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AutoSuggestBoxSuggestionChosenEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_AutoSuggestBoxTextChangedEventArgs_Static{PyType_FromSpec(&type_spec_AutoSuggestBoxTextChangedEventArgs_Static)};
    if (!type_AutoSuggestBoxTextChangedEventArgs_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_AutoSuggestBoxTextChangedEventArgs, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_AutoSuggestBoxTextChangedEventArgs_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_BitmapIcon_Static{PyType_FromSpec(&type_spec_BitmapIcon_Static)};
    if (!type_BitmapIcon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BitmapIcon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_BitmapIcon_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_BitmapIconSource_Static{PyType_FromSpec(&type_spec_BitmapIconSource_Static)};
    if (!type_BitmapIconSource_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BitmapIconSource, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_BitmapIconSource_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Border_Static{PyType_FromSpec(&type_spec_Border_Static)};
    if (!type_Border_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Border, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Border_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_BreadcrumbBar_Static{PyType_FromSpec(&type_spec_BreadcrumbBar_Static)};
    if (!type_BreadcrumbBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BreadcrumbBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_BreadcrumbBar_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BreadcrumbBarItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BreadcrumbBarItemClickedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Button_Static{PyType_FromSpec(&type_spec_Button_Static)};
    if (!type_Button_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Button, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Button_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_CalendarDatePicker_Static{PyType_FromSpec(&type_spec_CalendarDatePicker_Static)};
    if (!type_CalendarDatePicker_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CalendarDatePicker, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_CalendarDatePicker_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CalendarDatePickerDateChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_CalendarView_Static{PyType_FromSpec(&type_spec_CalendarView_Static)};
    if (!type_CalendarView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CalendarView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_CalendarView_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_CalendarViewDayItem_Static{PyType_FromSpec(&type_spec_CalendarViewDayItem_Static)};
    if (!type_CalendarViewDayItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CalendarViewDayItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_CalendarViewDayItem_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CalendarViewDayItemChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CalendarViewSelectedDatesChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CandidateWindowBoundsChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Canvas_Static{PyType_FromSpec(&type_spec_Canvas_Static)};
    if (!type_Canvas_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Canvas, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Canvas_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CheckBox, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ChoosingGroupHeaderContainerEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ChoosingItemContainerEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CleanUpVirtualizedItemEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ColorChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ColorPicker_Static{PyType_FromSpec(&type_spec_ColorPicker_Static)};
    if (!type_ColorPicker_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ColorPicker, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ColorPicker_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ColumnDefinition_Static{PyType_FromSpec(&type_spec_ColumnDefinition_Static)};
    if (!type_ColumnDefinition_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ColumnDefinition, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ColumnDefinition_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ColumnDefinitionCollection, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ComboBox_Static{PyType_FromSpec(&type_spec_ComboBox_Static)};
    if (!type_ComboBox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ComboBox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ComboBox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ComboBoxItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ComboBoxTextSubmittedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_CommandBar_Static{PyType_FromSpec(&type_spec_CommandBar_Static)};
    if (!type_CommandBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CommandBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_CommandBar_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CommandBarFlyout, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CommandBarOverflowPresenter, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContainerContentChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ContentControl_Static{PyType_FromSpec(&type_spec_ContentControl_Static)};
    if (!type_ContentControl_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentControl, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ContentControl_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ContentDialog_Static{PyType_FromSpec(&type_spec_ContentDialog_Static)};
    if (!type_ContentDialog_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentDialog, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ContentDialog_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentDialogButtonClickDeferral, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentDialogButtonClickEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentDialogClosedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentDialogClosingDeferral, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentDialogClosingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentDialogOpenedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ContentPresenter_Static{PyType_FromSpec(&type_spec_ContentPresenter_Static)};
    if (!type_ContentPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContentPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ContentPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ContextMenuEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Control_Static{PyType_FromSpec(&type_spec_Control_Static)};
    if (!type_Control_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Control, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Control_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ControlTemplate, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_CoreWebView2InitializedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DataTemplateSelector, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DatePickedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_DatePicker_Static{PyType_FromSpec(&type_spec_DatePicker_Static)};
    if (!type_DatePicker_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DatePicker, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_DatePicker_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_DatePickerFlyout_Static{PyType_FromSpec(&type_spec_DatePickerFlyout_Static)};
    if (!type_DatePickerFlyout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DatePickerFlyout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_DatePickerFlyout_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_DatePickerFlyoutItem_Static{PyType_FromSpec(&type_spec_DatePickerFlyoutItem_Static)};
    if (!type_DatePickerFlyoutItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DatePickerFlyoutItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_DatePickerFlyoutItem_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_DatePickerFlyoutPresenter_Static{PyType_FromSpec(&type_spec_DatePickerFlyoutPresenter_Static)};
    if (!type_DatePickerFlyoutPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DatePickerFlyoutPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_DatePickerFlyoutPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DatePickerSelectedValueChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DatePickerValueChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DragItemsCompletedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DragItemsStartingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DropDownButton, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_DynamicOverflowItemsChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Expander_Static{PyType_FromSpec(&type_spec_Expander_Static)};
    if (!type_Expander_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Expander, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Expander_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ExpanderCollapsedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ExpanderExpandingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ExpanderTemplateSettings, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_FlipView_Static{PyType_FromSpec(&type_spec_FlipView_Static)};
    if (!type_FlipView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_FlipView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_FlipView_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_FlipViewItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Flyout_Static{PyType_FromSpec(&type_spec_Flyout_Static)};
    if (!type_Flyout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Flyout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Flyout_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_FlyoutPresenter_Static{PyType_FromSpec(&type_spec_FlyoutPresenter_Static)};
    if (!type_FlyoutPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_FlyoutPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_FlyoutPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_FocusDisengagedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_FocusEngagedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_FontIcon_Static{PyType_FromSpec(&type_spec_FontIcon_Static)};
    if (!type_FontIcon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_FontIcon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_FontIcon_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_FontIconSource_Static{PyType_FromSpec(&type_spec_FontIconSource_Static)};
    if (!type_FontIconSource_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_FontIconSource, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_FontIconSource_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Frame_Static{PyType_FromSpec(&type_spec_Frame_Static)};
    if (!type_Frame_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Frame, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Frame_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Grid_Static{PyType_FromSpec(&type_spec_Grid_Static)};
    if (!type_Grid_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Grid, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Grid_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_GridView, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_GridViewHeaderItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_GridViewItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_GroupItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_GroupStyle, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_GroupStyleSelector, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_HasValidationErrorsChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Hub_Static{PyType_FromSpec(&type_spec_Hub_Static)};
    if (!type_Hub_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Hub, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Hub_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_HubSection_Static{PyType_FromSpec(&type_spec_HubSection_Static)};
    if (!type_HubSection_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_HubSection, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_HubSection_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_HubSectionCollection, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_HubSectionHeaderClickEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_HyperlinkButton_Static{PyType_FromSpec(&type_spec_HyperlinkButton_Static)};
    if (!type_HyperlinkButton_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_HyperlinkButton, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_HyperlinkButton_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_IconElement_Static{PyType_FromSpec(&type_spec_IconElement_Static)};
    if (!type_IconElement_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IconElement, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_IconElement_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_IconSource_Static{PyType_FromSpec(&type_spec_IconSource_Static)};
    if (!type_IconSource_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IconSource, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_IconSource_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_IconSourceElement_Static{PyType_FromSpec(&type_spec_IconSourceElement_Static)};
    if (!type_IconSourceElement_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IconSourceElement, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_IconSourceElement_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Image_Static{PyType_FromSpec(&type_spec_Image_Static)};
    if (!type_Image_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Image, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Image_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ImageIcon_Static{PyType_FromSpec(&type_spec_ImageIcon_Static)};
    if (!type_ImageIcon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ImageIcon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ImageIcon_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ImageIconSource_Static{PyType_FromSpec(&type_spec_ImageIconSource_Static)};
    if (!type_ImageIconSource_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ImageIconSource, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ImageIconSource_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_InfoBadge_Static{PyType_FromSpec(&type_spec_InfoBadge_Static)};
    if (!type_InfoBadge_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_InfoBadge, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_InfoBadge_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_InfoBadgeTemplateSettings_Static{PyType_FromSpec(&type_spec_InfoBadgeTemplateSettings_Static)};
    if (!type_InfoBadgeTemplateSettings_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_InfoBadgeTemplateSettings, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_InfoBadgeTemplateSettings_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_InfoBar_Static{PyType_FromSpec(&type_spec_InfoBar_Static)};
    if (!type_InfoBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_InfoBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_InfoBar_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_InfoBarClosedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_InfoBarClosingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_InfoBarTemplateSettings_Static{PyType_FromSpec(&type_spec_InfoBarTemplateSettings_Static)};
    if (!type_InfoBarTemplateSettings_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_InfoBarTemplateSettings, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_InfoBarTemplateSettings_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IsTextTrimmedChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemClickEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemCollection, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemCollectionTransition, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemCollectionTransitionCompletedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemCollectionTransitionProgress, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemCollectionTransitionProvider, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ItemContainer_Static{PyType_FromSpec(&type_spec_ItemContainer_Static)};
    if (!type_ItemContainer_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemContainer, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ItemContainer_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemContainerGenerator, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ItemsControl_Static{PyType_FromSpec(&type_spec_ItemsControl_Static)};
    if (!type_ItemsControl_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsControl, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ItemsControl_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsPanelTemplate, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsPickedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ItemsPresenter_Static{PyType_FromSpec(&type_spec_ItemsPresenter_Static)};
    if (!type_ItemsPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ItemsPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ItemsRepeater_Static{PyType_FromSpec(&type_spec_ItemsRepeater_Static)};
    if (!type_ItemsRepeater_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsRepeater, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ItemsRepeater_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsRepeaterElementClearingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsRepeaterElementIndexChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsRepeaterElementPreparedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsRepeaterScrollHost, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsSourceView, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ItemsStackPanel_Static{PyType_FromSpec(&type_spec_ItemsStackPanel_Static)};
    if (!type_ItemsStackPanel_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsStackPanel, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ItemsStackPanel_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ItemsView_Static{PyType_FromSpec(&type_spec_ItemsView_Static)};
    if (!type_ItemsView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ItemsView_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsViewItemInvokedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsViewSelectionChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ItemsWrapGrid_Static{PyType_FromSpec(&type_spec_ItemsWrapGrid_Static)};
    if (!type_ItemsWrapGrid_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ItemsWrapGrid, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ItemsWrapGrid_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Layout, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_LayoutContext, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_LinedFlowLayout_Static{PyType_FromSpec(&type_spec_LinedFlowLayout_Static)};
    if (!type_LinedFlowLayout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_LinedFlowLayout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_LinedFlowLayout_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_LinedFlowLayoutItemCollectionTransitionProvider, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_LinedFlowLayoutItemsInfoRequestedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ListBox_Static{PyType_FromSpec(&type_spec_ListBox_Static)};
    if (!type_ListBox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListBox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ListBox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListBoxItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ListPickerFlyout_Static{PyType_FromSpec(&type_spec_ListPickerFlyout_Static)};
    if (!type_ListPickerFlyout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListPickerFlyout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ListPickerFlyout_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListPickerFlyoutPresenter, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListView, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ListViewBase_Static{PyType_FromSpec(&type_spec_ListViewBase_Static)};
    if (!type_ListViewBase_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListViewBase, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ListViewBase_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListViewBaseHeaderItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListViewHeaderItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListViewItem, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ListViewPersistenceHelper_Static{PyType_FromSpec(&type_spec_ListViewPersistenceHelper_Static)};
    if (!type_ListViewPersistenceHelper_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ListViewPersistenceHelper, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ListViewPersistenceHelper_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MapControl_Static{PyType_FromSpec(&type_spec_MapControl_Static)};
    if (!type_MapControl_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MapControl, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MapControl_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MapControlMapServiceErrorOccurredEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MapElement, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MapElementClickEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MapElementsLayer_Static{PyType_FromSpec(&type_spec_MapElementsLayer_Static)};
    if (!type_MapElementsLayer_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MapElementsLayer, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MapElementsLayer_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MapIcon_Static{PyType_FromSpec(&type_spec_MapIcon_Static)};
    if (!type_MapIcon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MapIcon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MapIcon_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MapLayer, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MediaPlayerElement_Static{PyType_FromSpec(&type_spec_MediaPlayerElement_Static)};
    if (!type_MediaPlayerElement_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MediaPlayerElement, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MediaPlayerElement_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MediaPlayerPresenter_Static{PyType_FromSpec(&type_spec_MediaPlayerPresenter_Static)};
    if (!type_MediaPlayerPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MediaPlayerPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MediaPlayerPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MediaTransportControls_Static{PyType_FromSpec(&type_spec_MediaTransportControls_Static)};
    if (!type_MediaTransportControls_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MediaTransportControls, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MediaTransportControls_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MediaTransportControlsHelper_Static{PyType_FromSpec(&type_spec_MediaTransportControlsHelper_Static)};
    if (!type_MediaTransportControlsHelper_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MediaTransportControlsHelper, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MediaTransportControlsHelper_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MenuBar_Static{PyType_FromSpec(&type_spec_MenuBar_Static)};
    if (!type_MenuBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MenuBar_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MenuBarItem_Static{PyType_FromSpec(&type_spec_MenuBarItem_Static)};
    if (!type_MenuBarItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuBarItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MenuBarItem_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuBarItemFlyout, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MenuFlyout_Static{PyType_FromSpec(&type_spec_MenuFlyout_Static)};
    if (!type_MenuFlyout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuFlyout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MenuFlyout_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MenuFlyoutItem_Static{PyType_FromSpec(&type_spec_MenuFlyoutItem_Static)};
    if (!type_MenuFlyoutItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuFlyoutItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MenuFlyoutItem_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuFlyoutItemBase, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MenuFlyoutPresenter_Static{PyType_FromSpec(&type_spec_MenuFlyoutPresenter_Static)};
    if (!type_MenuFlyoutPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuFlyoutPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MenuFlyoutPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuFlyoutSeparator, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_MenuFlyoutSubItem_Static{PyType_FromSpec(&type_spec_MenuFlyoutSubItem_Static)};
    if (!type_MenuFlyoutSubItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_MenuFlyoutSubItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_MenuFlyoutSubItem_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_NavigationView_Static{PyType_FromSpec(&type_spec_NavigationView_Static)};
    if (!type_NavigationView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_NavigationView_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewBackRequestedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewDisplayModeChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_NavigationViewItem_Static{PyType_FromSpec(&type_spec_NavigationViewItem_Static)};
    if (!type_NavigationViewItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_NavigationViewItem_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_NavigationViewItemBase_Static{PyType_FromSpec(&type_spec_NavigationViewItemBase_Static)};
    if (!type_NavigationViewItemBase_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewItemBase, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_NavigationViewItemBase_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewItemCollapsedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewItemExpandingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewItemHeader, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewItemInvokedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewItemSeparator, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewPaneClosingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewSelectionChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_NavigationViewTemplateSettings_Static{PyType_FromSpec(&type_spec_NavigationViewTemplateSettings_Static)};
    if (!type_NavigationViewTemplateSettings_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NavigationViewTemplateSettings, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_NavigationViewTemplateSettings_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NonVirtualizingLayout, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NonVirtualizingLayoutContext, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_NumberBox_Static{PyType_FromSpec(&type_spec_NumberBox_Static)};
    if (!type_NumberBox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NumberBox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_NumberBox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_NumberBoxValueChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Page_Static{PyType_FromSpec(&type_spec_Page_Static)};
    if (!type_Page_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Page, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Page_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Panel_Static{PyType_FromSpec(&type_spec_Panel_Static)};
    if (!type_Panel_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Panel, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Panel_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ParallaxView_Static{PyType_FromSpec(&type_spec_ParallaxView_Static)};
    if (!type_ParallaxView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ParallaxView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ParallaxView_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_PasswordBox_Static{PyType_FromSpec(&type_spec_PasswordBox_Static)};
    if (!type_PasswordBox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PasswordBox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PasswordBox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PasswordBoxPasswordChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_PathIcon_Static{PyType_FromSpec(&type_spec_PathIcon_Static)};
    if (!type_PathIcon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PathIcon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PathIcon_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_PathIconSource_Static{PyType_FromSpec(&type_spec_PathIconSource_Static)};
    if (!type_PathIconSource_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PathIconSource, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PathIconSource_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_PersonPicture_Static{PyType_FromSpec(&type_spec_PersonPicture_Static)};
    if (!type_PersonPicture_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PersonPicture, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PersonPicture_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PersonPictureTemplateSettings, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PickerConfirmedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_PickerFlyout_Static{PyType_FromSpec(&type_spec_PickerFlyout_Static)};
    if (!type_PickerFlyout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PickerFlyout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PickerFlyout_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PickerFlyoutPresenter, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_PipsPager_Static{PyType_FromSpec(&type_spec_PipsPager_Static)};
    if (!type_PipsPager_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PipsPager, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PipsPager_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PipsPagerSelectedIndexChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PipsPagerTemplateSettings, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Pivot_Static{PyType_FromSpec(&type_spec_Pivot_Static)};
    if (!type_Pivot_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Pivot, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Pivot_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_PivotItem_Static{PyType_FromSpec(&type_spec_PivotItem_Static)};
    if (!type_PivotItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PivotItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_PivotItem_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_PivotItemEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ProgressBar_Static{PyType_FromSpec(&type_spec_ProgressBar_Static)};
    if (!type_ProgressBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ProgressBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ProgressBar_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ProgressBarTemplateSettings, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ProgressRing_Static{PyType_FromSpec(&type_spec_ProgressRing_Static)};
    if (!type_ProgressRing_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ProgressRing, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ProgressRing_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ProgressRingTemplateSettings, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RadioButton_Static{PyType_FromSpec(&type_spec_RadioButton_Static)};
    if (!type_RadioButton_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RadioButton, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RadioButton_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RadioButtons_Static{PyType_FromSpec(&type_spec_RadioButtons_Static)};
    if (!type_RadioButtons_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RadioButtons, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RadioButtons_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RadioMenuFlyoutItem_Static{PyType_FromSpec(&type_spec_RadioMenuFlyoutItem_Static)};
    if (!type_RadioMenuFlyoutItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RadioMenuFlyoutItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RadioMenuFlyoutItem_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RatingControl_Static{PyType_FromSpec(&type_spec_RatingControl_Static)};
    if (!type_RatingControl_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RatingControl, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RatingControl_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RatingItemFontInfo_Static{PyType_FromSpec(&type_spec_RatingItemFontInfo_Static)};
    if (!type_RatingItemFontInfo_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RatingItemFontInfo, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RatingItemFontInfo_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RatingItemImageInfo_Static{PyType_FromSpec(&type_spec_RatingItemImageInfo_Static)};
    if (!type_RatingItemImageInfo_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RatingItemImageInfo, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RatingItemImageInfo_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RatingItemInfo, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RefreshContainer_Static{PyType_FromSpec(&type_spec_RefreshContainer_Static)};
    if (!type_RefreshContainer_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RefreshContainer, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RefreshContainer_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RefreshInteractionRatioChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RefreshRequestedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RefreshStateChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RefreshVisualizer_Static{PyType_FromSpec(&type_spec_RefreshVisualizer_Static)};
    if (!type_RefreshVisualizer_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RefreshVisualizer, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RefreshVisualizer_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RelativePanel_Static{PyType_FromSpec(&type_spec_RelativePanel_Static)};
    if (!type_RelativePanel_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RelativePanel, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RelativePanel_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RevealListViewItemPresenter, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RichEditBox_Static{PyType_FromSpec(&type_spec_RichEditBox_Static)};
    if (!type_RichEditBox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RichEditBox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RichEditBox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RichEditBoxSelectionChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RichEditBoxTextChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RichTextBlock_Static{PyType_FromSpec(&type_spec_RichTextBlock_Static)};
    if (!type_RichTextBlock_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RichTextBlock, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RichTextBlock_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RichTextBlockOverflow_Static{PyType_FromSpec(&type_spec_RichTextBlockOverflow_Static)};
    if (!type_RichTextBlockOverflow_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RichTextBlockOverflow, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RichTextBlockOverflow_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_RowDefinition_Static{PyType_FromSpec(&type_spec_RowDefinition_Static)};
    if (!type_RowDefinition_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RowDefinition, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_RowDefinition_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_RowDefinitionCollection, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ScrollContentPresenter_Static{PyType_FromSpec(&type_spec_ScrollContentPresenter_Static)};
    if (!type_ScrollContentPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollContentPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ScrollContentPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ScrollView_Static{PyType_FromSpec(&type_spec_ScrollView_Static)};
    if (!type_ScrollView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ScrollView_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ScrollViewer_Static{PyType_FromSpec(&type_spec_ScrollViewer_Static)};
    if (!type_ScrollViewer_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollViewer, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ScrollViewer_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollViewerView, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollViewerViewChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollViewerViewChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingAnchorRequestedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingBringingIntoViewEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingScrollAnimationStartingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingScrollCompletedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingScrollOptions, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingZoomAnimationStartingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingZoomCompletedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ScrollingZoomOptions, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SectionsInViewChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SelectionChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SelectorBar_Static{PyType_FromSpec(&type_spec_SelectorBar_Static)};
    if (!type_SelectorBar_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SelectorBar, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SelectorBar_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SelectorBarItem_Static{PyType_FromSpec(&type_spec_SelectorBarItem_Static)};
    if (!type_SelectorBarItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SelectorBarItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SelectorBarItem_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SelectorBarSelectionChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SemanticZoom_Static{PyType_FromSpec(&type_spec_SemanticZoom_Static)};
    if (!type_SemanticZoom_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SemanticZoom, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SemanticZoom_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SemanticZoomLocation, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SemanticZoomViewChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Slider_Static{PyType_FromSpec(&type_spec_Slider_Static)};
    if (!type_Slider_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Slider, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Slider_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SplitButton_Static{PyType_FromSpec(&type_spec_SplitButton_Static)};
    if (!type_SplitButton_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SplitButton, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SplitButton_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SplitButtonClickEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SplitView_Static{PyType_FromSpec(&type_spec_SplitView_Static)};
    if (!type_SplitView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SplitView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SplitView_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SplitViewPaneClosingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_StackLayout_Static{PyType_FromSpec(&type_spec_StackLayout_Static)};
    if (!type_StackLayout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_StackLayout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_StackLayout_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_StackPanel_Static{PyType_FromSpec(&type_spec_StackPanel_Static)};
    if (!type_StackPanel_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_StackPanel, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_StackPanel_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_StyleSelector, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SwapChainBackgroundPanel, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SwapChainPanel_Static{PyType_FromSpec(&type_spec_SwapChainPanel_Static)};
    if (!type_SwapChainPanel_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SwapChainPanel, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SwapChainPanel_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SwipeControl_Static{PyType_FromSpec(&type_spec_SwipeControl_Static)};
    if (!type_SwipeControl_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SwipeControl, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SwipeControl_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SwipeItem_Static{PyType_FromSpec(&type_spec_SwipeItem_Static)};
    if (!type_SwipeItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SwipeItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SwipeItem_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SwipeItemInvokedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SwipeItems_Static{PyType_FromSpec(&type_spec_SwipeItems_Static)};
    if (!type_SwipeItems_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SwipeItems, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SwipeItems_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SymbolIcon_Static{PyType_FromSpec(&type_spec_SymbolIcon_Static)};
    if (!type_SymbolIcon_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SymbolIcon, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SymbolIcon_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_SymbolIconSource_Static{PyType_FromSpec(&type_spec_SymbolIconSource_Static)};
    if (!type_SymbolIconSource_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_SymbolIconSource, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_SymbolIconSource_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TabView_Static{PyType_FromSpec(&type_spec_TabView_Static)};
    if (!type_TabView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TabView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TabView_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TabViewItem_Static{PyType_FromSpec(&type_spec_TabViewItem_Static)};
    if (!type_TabViewItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TabViewItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TabViewItem_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TabViewItemTemplateSettings_Static{PyType_FromSpec(&type_spec_TabViewItemTemplateSettings_Static)};
    if (!type_TabViewItemTemplateSettings_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TabViewItemTemplateSettings, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TabViewItemTemplateSettings_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TabViewTabCloseRequestedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TabViewTabDragCompletedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TabViewTabDragStartingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TabViewTabDroppedOutsideEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TeachingTip_Static{PyType_FromSpec(&type_spec_TeachingTip_Static)};
    if (!type_TeachingTip_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TeachingTip, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TeachingTip_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TeachingTipClosedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TeachingTipClosingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TeachingTipTemplateSettings_Static{PyType_FromSpec(&type_spec_TeachingTipTemplateSettings_Static)};
    if (!type_TeachingTipTemplateSettings_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TeachingTipTemplateSettings, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TeachingTipTemplateSettings_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TextBlock_Static{PyType_FromSpec(&type_spec_TextBlock_Static)};
    if (!type_TextBlock_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextBlock, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TextBlock_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TextBox_Static{PyType_FromSpec(&type_spec_TextBox_Static)};
    if (!type_TextBox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextBox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TextBox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextBoxBeforeTextChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextBoxSelectionChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextBoxTextChangingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextCommandBarFlyout, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextCompositionChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextCompositionEndedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextCompositionStartedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextControlCopyingToClipboardEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextControlCuttingToClipboardEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TextControlPasteEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TimePickedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TimePicker_Static{PyType_FromSpec(&type_spec_TimePicker_Static)};
    if (!type_TimePicker_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TimePicker, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TimePicker_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TimePickerFlyout_Static{PyType_FromSpec(&type_spec_TimePickerFlyout_Static)};
    if (!type_TimePickerFlyout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TimePickerFlyout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TimePickerFlyout_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TimePickerFlyoutPresenter_Static{PyType_FromSpec(&type_spec_TimePickerFlyoutPresenter_Static)};
    if (!type_TimePickerFlyoutPresenter_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TimePickerFlyoutPresenter, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TimePickerFlyoutPresenter_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TimePickerSelectedValueChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TimePickerValueChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ToggleMenuFlyoutItem_Static{PyType_FromSpec(&type_spec_ToggleMenuFlyoutItem_Static)};
    if (!type_ToggleMenuFlyoutItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ToggleMenuFlyoutItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ToggleMenuFlyoutItem_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ToggleSplitButton_Static{PyType_FromSpec(&type_spec_ToggleSplitButton_Static)};
    if (!type_ToggleSplitButton_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ToggleSplitButton, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ToggleSplitButton_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ToggleSplitButtonIsCheckedChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ToggleSwitch_Static{PyType_FromSpec(&type_spec_ToggleSwitch_Static)};
    if (!type_ToggleSwitch_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ToggleSwitch, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ToggleSwitch_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ToolTip_Static{PyType_FromSpec(&type_spec_ToolTip_Static)};
    if (!type_ToolTip_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ToolTip, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ToolTip_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_ToolTipService_Static{PyType_FromSpec(&type_spec_ToolTipService_Static)};
    if (!type_ToolTipService_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ToolTipService, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_ToolTipService_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TreeView_Static{PyType_FromSpec(&type_spec_TreeView_Static)};
    if (!type_TreeView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TreeView_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewCollapsedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewDragItemsCompletedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewDragItemsStartingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewExpandingEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TreeViewItem_Static{PyType_FromSpec(&type_spec_TreeViewItem_Static)};
    if (!type_TreeViewItem_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewItem, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TreeViewItem_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewItemInvokedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TreeViewItemTemplateSettings_Static{PyType_FromSpec(&type_spec_TreeViewItemTemplateSettings_Static)};
    if (!type_TreeViewItemTemplateSettings_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewItemTemplateSettings, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TreeViewItemTemplateSettings_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewList, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TreeViewNode_Static{PyType_FromSpec(&type_spec_TreeViewNode_Static)};
    if (!type_TreeViewNode_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewNode, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TreeViewNode_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TreeViewSelectionChangedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_TwoPaneView_Static{PyType_FromSpec(&type_spec_TwoPaneView_Static)};
    if (!type_TwoPaneView_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_TwoPaneView, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_TwoPaneView_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_UIElementCollection, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_UniformGridLayout_Static{PyType_FromSpec(&type_spec_UniformGridLayout_Static)};
    if (!type_UniformGridLayout_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_UniformGridLayout, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_UniformGridLayout_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_UserControl_Static{PyType_FromSpec(&type_spec_UserControl_Static)};
    if (!type_UserControl_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_UserControl, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_UserControl_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_VariableSizedWrapGrid_Static{PyType_FromSpec(&type_spec_VariableSizedWrapGrid_Static)};
    if (!type_VariableSizedWrapGrid_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_VariableSizedWrapGrid, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_VariableSizedWrapGrid_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_Viewbox_Static{PyType_FromSpec(&type_spec_Viewbox_Static)};
    if (!type_Viewbox_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_Viewbox, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_Viewbox_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_VirtualizingLayout, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_VirtualizingLayoutContext, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_VirtualizingPanel, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_VirtualizingStackPanel_Static{PyType_FromSpec(&type_spec_VirtualizingStackPanel_Static)};
    if (!type_VirtualizingStackPanel_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_VirtualizingStackPanel, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_VirtualizingStackPanel_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_WebView2_Static{PyType_FromSpec(&type_spec_WebView2_Static)};
    if (!type_WebView2_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_WebView2, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_WebView2_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_WrapGrid_Static{PyType_FromSpec(&type_spec_WrapGrid_Static)};
    if (!type_WrapGrid_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_WrapGrid, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_WrapGrid_Static.get())) == -1)
    {
        return nullptr;
    }

    py::pyobj_handle type_XamlControlsResources_Static{PyType_FromSpec(&type_spec_XamlControlsResources_Static)};
    if (!type_XamlControlsResources_Static)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_XamlControlsResources, object_bases.get(), reinterpret_cast<PyTypeObject*>(type_XamlControlsResources_Static.get())) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IAnimatedVisual, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IAnimatedVisual2, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IAnimatedVisualSource, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IAnimatedVisualSource2, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IAnimatedVisualSource3, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ICommandBarElement, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IDynamicAnimatedVisualSource, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IInsertionPanel, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IItemContainerMapping, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IKeyIndexMapping, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_INavigate, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_IScrollAnchorProvider, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_ISemanticZoomInformation, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }


    return module.detach();
}
